Bugs in software can be minor annoyances, hilarious quirks, or catastrophic failures. From historical glitches to modern disasters, let’s explore 25 examples of bugs that left a mark on the world, grouped into tiers of escalating consequences.
Tier 1: Bugs That Made Us Laugh (Or Scratch Our Heads)
- Gandhi’s Nuclear Aggression
A quirk in Sid Meier’s Civilization turned pacifist Gandhi into a nuclear warlord due to an integer underflow. This beloved “bug” became a fan-favorite feature in later versions. - The Zune Freeze (2008)
Microsoft’s Zune devices froze worldwide due to a leap year bug that couldn’t handle the 366th day. - FaceTime Eavesdropping (2019)
A teenager found that adding your number to a group call on FaceTime allowed audio spying—and even camera activation if the recipient declined the call. - Chase ATM Glitch (2024)
Viral videos showed people withdrawing “free money” from Chase ATMs after depositing fake checks. Unfortunately, it all ended with lawsuits and overdrafts. - Vancouver Stock Exchange Rounding Error (1982)
A rounding error caused the stock index to slowly lose value over two years, dropping from 1000 to 520 before being recalculated. - Therac-25 Race Condition
A medical device overdosed patients with lethal radiation due to a race condition in its software, resulting in several fatalities.
Tier 2: Costly Mistakes
- Pentium FDIV Bug (1994)
Intel’s floating-point division bug caused rare calculation errors, costing the company millions in chip replacements. - AT&T Network Crash (1990)
A misplacedbreakstatement in a C program triggered a cascade of failures, blocking 50 million calls. - Toyota’s Brake Glitch (2010)
A software bug caused delays in braking, leading to recalls of 400,000 vehicles. - Heathrow Terminal 5 Chaos (2008)
A baggage system bug caused 500 canceled flights and lost 42,000 bags. Miscommunication between software systems was to blame. - Mars Climate Orbiter Crash (1999)
NASA lost $125 million due to a metric-imperial unit mismatch, burning the orbiter in Mars’ atmosphere. - Heartbleed (2014)
A missing bounds check in OpenSSL allowed attackers to extract sensitive server data, affecting two-thirds of the internet.
Tier 3: When Bugs Make History
- The Morris Worm (1988)
A graduate student’s experiment in measuring the internet’s size spiraled out of control, crashing 6,000 systems—10% of the internet at the time. - Night Capital’s $440 Million Error (2012)
A forgotten testing algorithm wreaked havoc on stock markets, wiping out Night Capital’s equity in 45 minutes. - The Y2K Bug (1999)
While mostly mitigated, the fear of two-digit year formats breaking systems spurred billions of dollars in preventive measures. - Ariane 5 Rocket Explosion (1996)
A floating-point to integer conversion error caused the rocket to self-destruct 37 seconds after liftoff. - CrowdStrike’s Y2K-Style Bug (2023)
A bad configuration file caused millions of machines to blue-screen, disrupting hospitals, flights, and more.
Tier 4: Lives on the Line
- Patriot Missile Clock Bug (1991)
A timer overflow caused the system to miss an incoming missile, resulting in 28 American soldiers’ deaths. - 737 MAX MCAS Failure (2018-2019)
Faulty data from a single sensor caused two crashes, killing 346 people and leading to the 737 MAX’s worldwide grounding. - Northeast Blackout (2003)
A bug in a power grid monitoring system caused cascading failures, leaving 50 million people without power. - Royal Air Force Helicopter Crash (1994)
Overloaded sensors confused a helicopter’s throttle control system, leading to a crash that killed 25 people.
Tier 5: Catastrophic Failures
- The Therac-25 Disaster
A radiation therapy machine overdosed patients due to inadequate error handling, resulting in multiple deaths. - Toyota’s Unintended Acceleration (2010)
Poor error handling and lack of redundancy in the throttle control system caused accidents that led to dozens of fatalities. - Aegis Combat System Misfire (1988)
A front-end interface bug caused a U.S. Navy system to misidentify a civilian aircraft as a hostile, leading to the deaths of 290 people. - Mars Climate Orbiter Redux (1999)
Similar to the original crash, NASA’s failures with metric-imperial unit mismatches are reminders of the consequences of sloppy coordination.
Lessons Learned
While these bugs vary in severity, they all highlight the importance of rigorous testing, clear communication, and responsible coding practices. Whether it’s a humorous quirk or a life-threatening failure, software bugs remind us of the immense responsibility that comes with programming.
As we continue to push the boundaries of technology, we must also strive for higher standards in reliability and ethics. After all, the next line of buggy code could change the world—for better or worse.
