Ken Thompson

Kenneth Lane Thompson (born 4 February 1943) wrote the first version of UNIX at Bell Labs in 1969, wrote the B language (the predecessor of C), published in 1968 the algorithm that made regular-expression search practical, and shared the 1983 ACM Turing Award with Dennis Ritchie. He went on to build Plan 9 and, with Rob Pike, to design UTF-8; and after thirty-four years at Bell he moved to Google in 2006 and co-designed the Go programming language with Pike and Robert Griesemer in 2009. Half a century of work leaving a visible mark on operating systems, programming languages, character encoding and tooling is an unusually wide track record for a single engineer.

Background

Thompson was born in New Orleans, Louisiana; his father was in the US Navy and the family moved often. He took his BS (1965) and MS (1966) in electrical engineering and computer science at UC Berkeley, and went straight from his master's into the Bell Labs Computing Sciences Research Center at Murray Hill, New Jersey, where he stayed until he retired in late 2000.

He was then a fellow at Entrisphere before joining Google as a Distinguished Engineer in 2006.

Major contributions

1969: UNIX

In August 1969, just after Bell Labs withdrew from Multics — the time-sharing system it had been building with MIT and General Electric — Thompson wrote the first version of UNIX on an unused DEC PDP-7 at Murray Hill. By his own account he wrote it in a month while his wife Bonnie was away, giving a week each to the kernel, the shell, an editor and an assembler.

The name was Brian Kernighan's suggestion. Ritchie dates it to "well into 1970" and calls it "a somewhat treacherous pun on 'Multics'"; the earlier spelling UNICS (UNiplexed Information and Computing Service) is widely reported.

What that first system had — and what it conspicuously did not have, including hierarchical path names and fork — is set out in the event article.

1969-1972: B and the road to C

The earliest UNIX was written in assembly. Thompson wrote B — a stripped-down, typeless BCPL — and used it to re-implement the non-kernel parts of the system. Ritchie added types to B and produced C; the kernel was rewritten in C in the summer of 1973. Portability was the consequence rather than the motive, but that one rewrite is what let UNIX move from the PDP-11 to the VAX, to workstations, and to PCs.

1968: the regular-expression search algorithm

Thompson built regular expressions into the QED editor and published the method in Communications of the ACM in June 1968 as "Regular expression search algorithm". It converts a regular expression into a nondeterministic finite automaton and represents the automaton's states as machine code generated on the fly — what is now called Thompson's construction. The UNIX text-processing vocabulary descends from it: ed, sed, awk, and the g/re/p command in ed that gave grep its name.

Belle and computer chess

With Joseph Condon, Thompson built the dedicated chess hardware Belle. It won the third World Computer Chess Championship at Linz in 1980 and the ACM North American Computer Chess Championship five times — in 1978, 1980, 1981, 1982 and 1986 — and it was, in the ACM's words, the first computer to attain a master rating. It stands in the lineage that runs to Deep Blue (1997).

1984: "Reflections on Trusting Trust"

Thompson's 1983 Turing Award lecture, published in CACM in August 1984, constructed a compiler back door that survives recompilation. The paper's epigraph:

To what extent should one trust a statement that a program is free of Trojan horses? Perhaps it is more important to trust the people who wrote the software.

The section headed MORAL is shorter still: "You can't trust code that you did not totally create yourself. (Especially code from companies that employ people like me.)" Forty years on, it is still read as a founding text of supply-chain security thinking.

Plan 9 and UTF-8

Through the late 1980s and 1990s Thompson worked with Rob Pike and others on Plan 9 from Bell Labs, a distributed operating system that pushed the UNIX "everything is a file" principle out across the network. Out of that work came UTF-8, which Thompson and Pike designed in 1992: a variable-length, self-synchronising encoding of Unicode that is byte-compatible with ASCII. It is now the dominant character encoding on the Web.

2009: the Go language

At Google, Thompson began designing a new language with Rob Pike (his former Bell Labs colleague) and Robert Griesemer (who had worked on Google's V8 JavaScript engine and was a founding member of the Java HotSpot VM team). Pike's own account dates the conception to late 2007, and repeats what he calls the origin myth: "When builds are slow, there is time to think. The origin myth for Go states that it was during one of those 45 minute builds that Go was conceived."

Released in November 2009, Go was built around goroutines for lightweight concurrency, channels for communication between them, interface types for structural typing, and a small grammar with fast compilation. Docker (2013), Kubernetes (2014), Terraform and much of the cloud-native tool chain are written in it.

Awards and honours

The Turing citation reads: "With Dennis M. Ritchie, for their development of generic operating systems theory and specifically for the implementation of the UNIX operating system."

Personal style and influence

Thompson is unusually quiet for an engineer of his standing — few talks, few interviews. Ritchie's description of how the collaboration started is the one that has lasted:

It began in 1969 when Ken Thompson discovered a little-used PDP-7 computer and set out to fashion a computing environment that he liked. His work soon attracted me; I joined in the enterprise, though most of the ideas, and most of the work for that matter, were his.

His legacy in 2026 runs on four layers. The UNIX line — the Linux kernel powers Android, Chromebooks, and nearly every public-cloud server. The C line — B to C and everything descended from it. UTF-8 — almost all text on the Web. And the Go line — the working language of cloud-native infrastructure through Docker, Kubernetes, and the surrounding ecosystem.

Writing one operating system, or designing one widely-used language, would be enough to enter the history of computing. Thompson did each, twice over, across two employers separated by four decades.