Ken Thompson has spent most of his career proving that software does not become better by becoming more complicated.
He helped create Unix, one of the most influential operating systems in computing history. Decades later, already a Turing Award winner and a legend in computer science, he helped create Go at Google.
The connection between those two achievements is not accidental.
Thompson had already seen what uncontrolled complexity could do. In the 1960s, he worked on Multics, an ambitious operating system designed to do almost everything. The project became so elaborate that its documentation reportedly filled meters of shelf space before the system was even finished. Thompson later described this kind of over-engineering as the “second-system effect”: after one successful system, engineers try to put everything into the next one.
His reaction was Unix.
Instead of building another giant system, Thompson worked on something radically smaller. According to his recollection, while his wife and young son were away for three weeks, he used the time to build the essential pieces of an operating system on an old PDP-7: an editor, an assembler and a kernel. Unix grew from that philosophy of reducing a system to what actually mattered.
Nearly forty years later, Thompson saw the same problem returning at Google.
Large C++ codebases had become painfully expensive to compile. Engineers could wait fifteen minutes—or even more than an hour—for large builds. The problem was not merely slow computers. It was software complexity accumulating faster than teams could control it.
In 2007, Thompson joined Rob Pike and Robert Griesemer to design a new language. Their rule was unusually strict: a feature would not enter Go unless all three believed it was exactly right. The goal was not to build the most powerful language possible. It was to build the smallest language that could solve the problems they actually had.
Programmers mocked that simplicity. Go lacked features considered essential in other modern languages. For years it had no generics, no inheritance hierarchy and no traditional exception system. Critics called it simplistic, even a language designed for mediocre programmers.
Then the cloud happened.
Docker adopted Go. Kubernetes was written in Go. So were etcd, Terraform, Prometheus, Helm and many other tools that became foundational to modern infrastructure. Go’s supposedly boring advantages (fast compilation, easy deployment, readable code and simple binaries) turned out to be exactly what infrastructure teams needed.
That is Thompson’s real legacy.
He did not merely help invent Unix and Go. He spent decades demonstrating a harder engineering principle: adding capabilities is easy. Knowing what to leave out is the difficult part.
In an industry obsessed with sophistication, Ken Thompson built some of its most important systems by removing things.
