Tony Hoare, the computer scientist who invented quicksort and won the 1980 Turing Award, died March 5, 2026 at age 92. While most developers know him for the sorting algorithm taught in every CS class, Hoare’s most lasting impact might be what he called his “billion-dollar mistake”—the null reference.
The Confession That Changed Everything
In 2009, Hoare stood before a packed QCon London audience and made an admission few computer science legends would dare: “I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object-oriented language—ALGOL W. My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn’t resist the temptation to put in a null reference, simply because it was so easy to implement.”
That phrase—”so easy to implement”—captures the core irony. Hoare chose implementation convenience over long-term safety. The result? Decades of NullPointerExceptions in Java, segmentation faults in C, “cannot read property of undefined” in JavaScript, and countless debugging hours tracking down null pointer errors that stack traces can’t actually diagnose.
The security costs compound the pain. OWASP lists null dereference as a major vulnerability. Attackers exploit null pointers to bypass security logic, cause buffer overflows, and inject malicious code. The “billion dollars” was hyperbole in 2009. By 2026, it might have been conservative.
How His Honesty Fixed What His Convenience Broke
Here’s the twist: Hoare’s confession sparked the solution. Modern languages designed after his 2009 talk prioritized null safety in ways earlier languages never did.
Rust eliminated raw null entirely. Its Option<T> type forces you to explicitly handle the Some and None cases—the compiler won’t let you dereference a potentially absent value. No null pointer exceptions possible.
Swift introduced optionals with clean syntax. A String? can be nil; a String cannot. Developers must use if-let or guard statements to safely unwrap optionals. The type system encodes presence and absence.
Kotlin made non-nullable types the default. You opt into nullability with String?, and the language provides safe call operators like ?. to handle null values gracefully without crashes.
Even TypeScript added strictNullChecks mode, separating null and undefined from all other types. Variables must explicitly include null in their type declarations if they’re nullable.
The pattern is clear: Languages learned from Hoare’s mistake. But they needed him to say it out loud first. A Turing Award winner admitting a fundamental design error legitimized the conversation. His honesty gave permission to do better.
Beyond the Mistake
Hoare’s legacy extends far past null references. Quicksort, which he invented in 1959 while trying to alphabetize Russian words for a machine translation project, remains a foundational algorithm. It’s the default sort in Unix, the basis for C’s qsort(), and taught to every computer science student.
Hoare logic—his formal system for reasoning about program correctness—laid the groundwork for modern verification tools. The {P} C {Q} notation (precondition, command, postcondition) is still how we prove programs behave as intended.
His 1978 work on Communicating Sequential Processes influenced how we think about concurrency. CSP’s message-passing model shaped Go’s goroutines, Erlang’s actor model, and Clojure’s core.async. The 1980 Turing Award recognized these “fundamental contributions to the definition and design of programming languages.”
But here’s what makes Hoare remarkable: He wasn’t just brilliant. He was honest about his failures. Colleagues remember his intellectual humility, his sense of humor, and a story about betting his boss sixpence that he knew a faster sorting algorithm than the one he’d already implemented. He won the bet and got paid—that algorithm was quicksort.
The Real Lesson
Null pointer errors persist today despite decades of improvements. Rust developers still call unwrap() on None and panic. Swift developers force unwrap with ! and crash. Kotlin’s !! operator bypasses null safety. Legacy C, C++, and Java codebases remain riddled with potential null dereferences.
But modern languages provide the tools to avoid these errors—tools that exist because Tony Hoare admitted he was wrong. His greatest contribution might be demonstrating that acknowledging mistakes can spark more progress than hiding them. Every Option<T>, every optional binding, every null safety feature in 2026 traces back to a Turing winner having the courage to say: “I was wrong. And here’s the cost.”
The billion-dollar mistake bought us something valuable: A generation of languages designed to prevent it. That’s a legacy worth honoring.
