“One of my most productive days was throwing away 1,000 lines of code.”
The Story
Ken Thompson built Unix on a PDP-7 in 1969, essentially as a side project. Bell Labs had pulled out of the Multics project — a bloated, over-engineered operating system that tried to be everything to everyone — and Thompson wanted something small enough to understand. He wrote an operating system, a shell, an editor, and an assembler in three weeks. Dennis Ritchie joined the effort, and together they created what would become the foundation for nearly every operating system that matters today: Linux, macOS, Android, iOS. All Unix descendants.
Before Unix, Thompson created the B programming language, which Ritchie later evolved into C. He built the first implementation of regular expressions for the ed text editor — the same regex engine concept that powers every search bar, every input validator, every log parser in modern software. He also created one of the first computer chess programs, Belle, which became the first to achieve master-level play.
In the 2000s, dissatisfied with the state of systems programming, Thompson joined Robert Griesemer and Rob Pike at Google to create Go. The language was a deliberate reaction to the complexity of C++ and Java — fast compilation, garbage collection, built-in concurrency, and a syntax so minimal that the entire language specification fits in a short document. Thompson was in his sixties. Most engineers that age are writing memoirs. He was writing a new language.
But the contribution that earns Thompson his place among the Breakers is his 1984 Turing Award lecture, "Reflections on Trusting Trust."
Why They're in the Hall
Thompson is Pioneer, Builder, and Breaker — and the Breaker designation is the one that matters most to TechnicalDepth.
Pioneer and Builder: Unix and its philosophy — small programs that do one thing well, composed via pipes — is the architectural pattern that the entire modern software stack descends from. The shell, the filesystem hierarchy, the process model, permissions, file descriptors: these are Thompson's design decisions, still running underneath every container, every cloud instance, every CI pipeline.
Breaker: In "Reflections on Trusting Trust," Thompson demonstrated something that should keep every software engineer awake at night. He showed that a C compiler could be modified to do two things: first, insert a backdoor into any login program it compiled; and second, insert the code that inserts the backdoor into any compiler it compiled — including future versions of itself. Then the modification could be removed from the compiler's source code entirely. The binary would propagate the backdoor forever, with no trace in any source code anywhere.
This is not a theoretical attack. It is a proof that trust in software is fundamentally transitive. You trust your application because you trust your compiler. You trust your compiler because you trust the compiler that compiled it. But if any link in that chain was ever compromised — and you didn't build every link yourself, from hardware up — you cannot know.
Every supply-chain attack documented in TechnicalDepth's disaster archives is a footnote to Thompson's lecture. SolarWinds, the XZ Utils backdoor, compromised npm packages — they are all variations on the theme Thompson articulated in 1984: you can't trust code you didn't write, and you can't fully trust code you did.
His most famous quote — about throwing away a thousand lines of code — captures the other half of his philosophy. The best code is the code that doesn't exist. Every line is a liability. Unix was great because it was small. Go is useful because it's boring. Thompson's career is a forty-year argument that simplicity is the only real defense against the complexity that breeds bugs.