Famous software bugs

Software fails all the time — billions of times a day, quietly, in ways nobody notices. But a handful of bugs crossed over: they killed patients in their hospital beds, vaporized rockets in mid-air, erased companies in forty-five minutes, and grounded every flight on a continent. These are the bugs famous enough to earn names — the inductees of the Software Bug Hall of Infamy. This is the countdown, from #10 to #1, escalating by the damage done.^[1]

The nameplate: a literal bug (1947)

Before the countdown, the plaque at the door. On 9 September 1947, operators of the Harvard Mark II electromechanical computer found the machine malfunctioning. Tracing the fault to relay #70, panel F, they opened it and found the cause: a moth, dead between the contacts. They taped it into the logbook and wrote, famously: "First actual case of bug being found." The page now lives at the Smithsonian.^[2]

One honest correction to the legend: "bug" for a technical defect predates computing by decades — Edison used it in the 1870s — and Grace Hopper, often credited with finding the moth, popularized the story rather than making the log entry herself. But the legend earned its place: the moth made "debugging" literal, and it remains the only bug whose remains are in a museum.^[3]

Now — the inductees, ranked.

10. Mars Pathfinder — the bug debugged from 140 million miles away (1997)

The only entry whose fix happened on another planet. Days after landing in July 1997, the Pathfinder lander began resetting itself mid-task — its VxWorks operating system kept hitting watchdog timeouts. On Earth, engineers reproduced it: a low-priority task held the information bus while a medium-priority task starved the high-priority one — a priority inversion, the subtlest known class of concurrency bug. The fix — enabling priority inheritance — was encoded and radioed 140 million miles to a machine sitting on Mars, where it took effect and ended the resets. NASA published the diagnosis in a now-famous engineering report titled "What Really Happened on Mars," which remains required reading in real-time systems courses.^[4]

9. The AT&T crash — one line of C silences America (1990)

On 15 January 1990, every long-distance call in the United States began failing — roughly half of all attempted calls, for nine hours. The cause was a routine software update to AT&T's 4ESS switches: inside a switch statement, a break was placed inside an if block — breaking out of the wrong structure and skipping the code that reset an error flag. When one switch hit a fault and reset itself, it signaled neighbors it was ready for traffic while still compromised; each neighbor then crashed, reset, and propagated the fault — a cascading failure across 114 switches. One keyword, one wrong scope, and the entire national telephone network folded like dominoes. It remains the canonical example of why switch fallthrough semantics are feared.^[5]

8. Mars Climate Orbiter — $327 million over a unit conversion (1999)

On 23 September 1999, the Mars Climate Orbiter fired its main engine to enter orbit — and burned up in the Martian atmosphere instead. The investigation found an almost insulting cause: Lockheed Martin's ground software produced impulse data in pound-force seconds; NASA's navigation software expected newton-seconds — a factor of 4.45 error that pushed the trajectory ~57 km too low. $327.6 million and a nine-month mission, destroyed not by a logic error but by nobody checking the units in the interface specification. NASA's post-mortem led directly to the "measurement systems" clauses now standard in aerospace contracts.^[6]

7. Pentium FDIV — the $475 million rounding error (1994)

Professor Thomas Nicely noticed his computations drifting slightly and traced it to Intel's flagship Pentium: the chip's SRT division algorithm referenced a lookup table into which five entries had never been loaded — for rare operand pairs, the FPU returned subtly wrong quotients, off by about one part in a thousand. Intel's first response — "an extremely rare condition" — became a case study in how not to handle a defect. The public forced a recall: Intel offered replacement chips to anyone who asked and took a $475 million charge. It was the first time a hardware bug became front-page consumer news.^[7]

6. Ariane 501 — 37 seconds, $370 million, one overflow (1996)

On its maiden flight — 4 June 1996 — the new Ariane 5 rocket veered off course and self-destructed 37 seconds after liftoff, taking four Cluster satellites with it. The cause: the inertial reference software had been reused verbatim from Ariane 4. The older rocket's horizontal velocity fit in 16 bits; the Ariane 5 flew a different trajectory, and the real value overflowed the 16-bit signed integer the code tried to convert it into — an operand error that killed both redundant computers simultaneously. The inquiry's phrase became legendary in software circles: the code was correct — for the wrong rocket. Cost: roughly $370 million and years of program delay.^[8]

5. The Morris worm — the night the internet broke (1988)

On 2 November 1988, a 23-year-old Cornell graduate student named Robert Tappan Morris released a program that exploited a buffer overflow in fingerd and a debug-mode hole in sendmail. It was supposed to spread slowly and gauge the internet's size — but a design flaw meant infected machines kept getting re-infected, each copy spawning more copies until hosts collapsed under their own load. An estimated 6,000 machines — roughly 10% of the entire internet — went down in a night. Morris became the first person convicted under the Computer Fraud and Abuse Act. Every worm since — ILOVEYOU, Code Red, WannaCry — runs in his shadow.^[9]

4. Knight Capital — the $440 million typo (2012)

On 1 August 2012, Knight Capital Group — then handling ~10% of US equity volume — deployed new code to its trading servers. One server missed the update and still ran dead code: an old "Power Peg" testing routine that a repurposed flag had silently reactivated, which bought high and sold low as fast as possible. For 45 minutes the algorithm hemorrhaged — 4 million executions across 154 stocks — while engineers, lacking a kill switch, hunted the cause. Knight lost $440 million — about $10 million per minute — and never recovered, folding into a merger within months. The SEC's lesson: it wasn't a bug in logic; it was a bug in deployment discipline.^[10]

3. CrowdStrike — the worst day in IT history (2024)

On 19 July 2024, a routine content update to CrowdStrike's Falcon security sensor shipped a channel file whose data triggered an out-of-bounds memory read in the sensor driver — and instantly sent roughly 8.5 million Windows machines into the blue screen of death, worldwide, in one stroke. Airlines grounded thousands of flights. Hospitals postponed surgeries. 911 call centers went dark. It stands as the largest IT outage ever recorded — an estimated $5.4 billion in damage to Fortune 500 companies alone — and the definitive proof that a single bytes-wide defect, pushed globally in minutes, can freeze a civilization's infrastructure.^[11]

2. Boeing 737 MAX MCAS — when the design is the bug (2018–19)

The deadliest entry is also the most disputed as a "bug" — and the honest treatment requires saying so. The Maneuvering Characteristics Augmentation System worked as designed: it pushed the nose down when the angle-of-attack sensor reported a stall. The catastrophic flaw was architectural — MCAS depended on a single AOA sensor and could fire repeatedly. Lion Air 610 and Ethiopian 302 — 346 people — died in two near-identical crashes five months apart; the fleet grounded for 20 months and Boeing paid over $20 billion. The code did what it was told. What failed was the engineering discipline around it — which is precisely why it belongs here: the deadliest software bugs are the ones whose specification was the defect.^[12]

1. Therac-25 — the code that killed (1985–87)

The worst bug ever written is the one that made "software safety" a profession. The Therac-25 was a radiation-therapy machine whose predecessor's hardware interlocks had been replaced by software control. Two defects combined: a race condition — a fast-typing operator could finish edits before the machine's concurrent tasks resynchronized — and an integer-overflow flag that zeroed out its own safety check every 256th pass. In both failure paths, the machine could enter a state delivering electron-beam doses up to ~100× intended — patients described feeling "fire" and later died or suffered horrific radiation injuries. At least six documented overdoses, several fatal, occurred between 1985 and 1987 before the FDA forced a fix. Nancy Leveson's investigation became the textbook case — the moment the industry learned that "it compiles and usually works" is not a safety argument.^[13]

The ledger — the hall at a glance

Dishonorable mentions

• Patriot missile, Dhahran (1991) — a 24-bit clock approximation of 0.1 seconds drifted ~0.34 s after 100 hours of uptime; the tracking gate missed an incoming Scud by ~600 m. 28 soldiers died. The fix had shipped — it just hadn't been installed yet.^[14]
• Y2K (2000) — two-digit years threatened civilization's date arithmetic; the world spent an estimated $100 billion on remediation and the rollover passed almost quietly. The most expensive bug — precisely because it was fixed.^[15]
• Toyota unintended acceleration (2009–10) — investigations found possible stack overflow and memory corruption in the engine ECU; dozens of deaths were attributed to unintended acceleration and Toyota paid a $1.2 billion settlement. Causation remains disputed — listed honestly.^[16]
• Heartbleed (2014) — a missing bounds check in OpenSSL's heartbeat let anyone read server memory; ~17% of the web's TLS servers leaked private keys for two years. The bug that proved internet infrastructure ran on volunteers' spare time.^[17]

What the hall teaches

Every inductee failed differently — an overflow, a unit, a scope, a race, a flag, a sensor. But the pattern underneath is one sentence: the code did exactly what it was written to do, and what it was written to do was wrong in a way nobody checked. The hall's real lesson isn't that programmers err — it's that these ten disasters were all preventable by the boring things: interface specifications, kill switches, hardware interlocks, and asking what the software does when the inputs are impossible.^[18]

Frequently asked

• What was the first software bug? The Harvard Mark II moth of 9 September 1947 — though "bug" for a defect predates computing by ~70 years.
• What is the deadliest software bug? By direct software fault, Therac-25; by software-involved design, the 737 MAX's MCAS — 346 deaths.
• What is the most expensive software bug? Y2K remediation (~$100B, spent preventing failure); for a single live incident, CrowdStrike's ~$5.4B day.
• What is the fastest a bug has destroyed money? Knight Capital — ~$10 million per minute for 45 minutes.

See also

• History of programming
• Compilers
• Dead programming languages
• Scientific notation