Tony Hoare died this month at 91. The announcement on Computational Complexity is brief, as these things often are, but the work it points to is anything but.
Most programmers know Hoare through Quicksort, which he invented in 1959 while working on a machine translation project. The algorithm is so familiar now that it reads almost like a natural law: partition around a pivot, recurse on each side, done. But the insight behind it, that you could sort efficiently by exploiting the structure of comparison rather than fighting it, was not obvious at the time. It became the default sorting strategy in countless standard libraries, and it still is.
Less celebrated, but arguably more consequential, is Hoare logic. Published in 1969, it gave us a formal way to reason about program correctness using preconditions, postconditions, and invariants. The notation is simple enough to fit on a whiteboard, but the idea behind it is foundational: code is not just a sequence of instructions, it is a proof of something. Every function can be understood as a transformation from one set of guaranteed conditions to another. That framing is everywhere now, in type systems, in test-driven development, in formal verification tools, in the way we think about contracts and interfaces in software design.
Then there is CSP, Communicating Sequential Processes, introduced in 1978. Where most concurrency work at the time focused on shared memory and locks, CSP proposed something different: independent processes that communicate by passing messages through channels. The insight was that the communication itself could be the unit of synchronization, not the memory beneath it. Go’s goroutines and channels descend directly from this model. Erlang’s actor system carries its fingerprints. When you write a channel pipeline in Go today, you are using an abstraction that Hoare sketched out nearly fifty years ago.
Hoare also gave us the phrase that has aged into something like a proverb. In his 2009 QCon talk, he called null references his “billion dollar mistake,” a shorthand for the accumulated cost of null pointer exceptions, defensive null checks, and the general anxiety that any reference in any program might secretly point to nothing. He invented null references himself, in 1965, because it was easy to implement. He spent decades afterward watching the industry suffer for it. There is something worth sitting with in that: a brilliant person making a practical shortcut, then living long enough to understand its full cost.
What strikes me most about his career is how many of his ideas arrived before the infrastructure existed to make them popular. CSP preceded the multi-core era by decades. Hoare logic arrived before most practical type systems had caught up with it. The ideas had to wait for the hardware, the languages, and the community to grow into them.
Computing has a short memory. We absorb foundational ideas so thoroughly that we stop seeing them as choices someone made. Quicksort is just how sorting works. Channels are just how you do concurrency in Go. Preconditions and postconditions are just how you think about functions. Hoare made a lot of those defaults, and that is about as lasting a contribution as anyone in this field has managed.