Intriguing Stories in Computer Science

I am now... of a certain age... and there's a ton of anecdotes in the history of computer science and software development that I've heard, but I wondered if there's more. I had an LLM compiler a list (though I've carefully reviewed and fixed a bunch of the links). Many of these I had heard before but some were new to me. Click through them if you're interested. Most of the links go to Wikipedia; I've made sure the links at least don't go to slop content farm websites.

The prompt I used was, loosely, "Tony Hoare has a comment about "null" being his billion dollar mistake. What are some other intriguing stories about programming and software design, either positive or negative?" (Though the start of the list is dominated by computer glitch stories, and it seems to stray into concepts more than stories.)

Raymond Chen is a venerable Microsoft engineer and his blog The Old New Thing (and book of the same name) has a ton of great stories. Joel Spolsky's blog Joel on Software is also a classic source for stories and guidance.

• Tony Hoare’s “billion-dollar mistake” — inventing the null reference.
• Ariane 5 Flight 501 — a reused integer conversion overflow destroyed the rocket.
• Mars Climate Orbiter — metric/imperial unit mismatch lost a spacecraft.
• Therac-25 — race conditions and poor safety design caused lethal radiation overdoses.
• Knight Capital — a botched deployment lost about $440 million in 45 minutes.
• Patriot missile failure — accumulated floating-point timing error contributed to 28 deaths. This article also links to Wikipedia's lethal autonomous weapons article.
• Pentium FDIV bug — a tiny lookup-table error caused incorrect division results, leading to the first full recall of a computer chip, costing $475 million.
• Heartbleed — missing bounds checking exposed arbitrary server memory.
• Morris worm — an experiment in self-replicating software accidentally crippled much of the early Internet.
• AT&T’s 1990 outage — one faulty recovery path caused cascading telephone-switch failures. (The entire List of software bugs article is interesting.)
• Cloudflare’s 2019 regex outage — catastrophic backtracking consumed CPUs across its network.
• GitLab’s 2017 database incident — an administrator accidentally deleted production data during recovery.
• Unix pipes — Doug McIlroy’s composability idea became one of computing’s most durable design patterns, also known as "Unix philosophy"
• Unix “everything is a file” — a simplifying abstraction that made unrelated tools work together.
• C’s gets() — an API so inherently unsafe it was eventually removed from the language standard.
• Java’s checked exceptions — a deliberate safety feature that became one of the language’s longest-running design controversies.
• JavaScript’s 10-day creation — Complete jerkwad and crypto shill Brendan Eich’s rushed implementation left quirks that shaped the web for decades.
• The browser “quirks mode” — deliberately preserving old bugs became necessary for web compatibility.
• Goto Considered Harmful — Dijkstra’s short letter helped ignite the structured-programming revolution.
• Netscape’s rewrite — throwing away the old browser code became a canonical warning about full rewrites.
• SQLite’s testing culture — an unusually exhaustive test system became central to its reputation for reliability.
• Erlang’s “let it crash” — designing systems around failure rather than trying to prevent every failure.
• Smalltalk’s “message passing” — object-oriented programming emerged from a much richer idea than classes and inheritance.
• The Lisp garbage collector — automatic memory management, once radical, became mainstream decades later.
• The Algol 60 report — unusually precise language specification influenced generations of programming-language design.
• The C++ “zero-overhead principle” — abstractions should cost nothing beyond what hand-written lower-level code would cost.
• Rust’s borrow checker — moving memory-safety rules into the type system challenged assumptions about systems programming.
• The Space Shuttle software — famously conservative engineering achieved exceptionally low defect rates. "The Legacy of Space Shuttle Flight Software" is an 83 page document.
• The Toyota unintended-acceleration software litigation — exposed how tangled embedded code can become a safety issue.
• The Y2K problem — two-digit year shortcuts created a vast, expensive maintenance exercise decades later. Oh my god, people who are 30 years old today don't remember Y2K. Oh god, I am so old.
• The 2038 problem — Unix’s 32-bit time representation repeats the lesson with a different integer.
• The leap-second bugs — seemingly harmless assumptions about time have repeatedly crashed large systems.
• Debian’s OpenSSL bug — removing “uninitialized” code that looked wrong drastically weakened random-number generation.
• Apple’s goto fail bug — a duplicated line bypassed TLS certificate verification.
• Left-pad — deleting an 11-line npm package temporarily broke large portions of the JavaScript ecosystem.
• Log4Shell — a convenient logging feature composed into a catastrophic remote-code-execution vulnerability.
• The DAO hack — software behavior overrode human intent and forced Ethereum into a controversial fork.
• Excel’s 1900 leap-year bug — intentionally preserved for compatibility with Lotus 1-2-3.
• Excel gene-name corruption — automatic date conversion silently altered scientific datasets for years.
• Hyrum’s Law — with enough users, every observable behavior becomes somebody’s dependency. There is, of course, an XKCD comic about the concept.
• Postel’s Law — “be liberal in what you accept” helped interoperability, then became controversial for security reasons. (I, for one, absolutely disagree with its sentiment.)
• Greenspun’s Tenth Rule — complex programs often accidentally reinvent half of Common Lisp.
• Conway’s Law — software architectures tend to mirror the communication structures of their organizations.
• Gall’s Law — complex working systems usually evolve from simple working systems, not from grand designs.
• Worse is Better — Richard Gabriel’s argument that simplicity of implementation can beat theoretical perfection. The Wikipedia article also links to the article for The UNIX-HATERS Handbook
• The Second-System Effect — successful engineers often overdesign their next project.
• The Mythical Man-Month — adding people to a late software project can make it later.
• NASA’s “Power of Ten” rules — extreme coding restrictions proposed for safety-critical software.
• Doom’s source code — compact, pragmatic engineering became a classic study in game-system architecture. Reminds me of the DOOMed to Fail: A Horror Story episode of the CoRecursive podcast with guest Rebecca Heineman (RIP).
• Quake’s fast inverse square root — a legendary bit-level optimization with a mysterious magic constant.
• Git’s creation — Linus Torvalds built the first version rapidly after losing access to BitKeeper.
• Git’s content-addressed design — treating objects by hashes made distributed version control unusually robust.
• Plan 9 — many elegant Unix ideas were rethought cleanly, yet commercial adoption remained tiny.
• TCP congestion collapse — the Internet nearly melted down before Van Jacobson’s congestion-control algorithms.
• DNS — replacing a centrally maintained hosts file with a distributed hierarchical system enabled Internet-scale naming.
• Amazon’s Dynamo (and paper on the system) — accepting eventual consistency helped popularize modern distributed-database design.
• Google’s MapReduce (and paper on the system) — a simple programming model made enormous distributed computations manageable.
• Leslie Lamport’s Paxos paper — a foundational consensus algorithm was famously difficult for readers to understand.
• Raft (original paper) — explicitly designed to make consensus understandable without substantially weakening it.
• The Byzantine Generals Problem — a thought experiment became foundational to fault-tolerant distributed systems.
• CAP theorem — formalized an unavoidable tradeoff that many database designs had previously treated informally.