Computer scientist, systems programmer

Ken Thompson

3 records 1971 to 1984 Technical Papers Operating Systems

The systems programmer who built Unix with Dennis Ritchie, then rigged its compiler to show how far a clean source tree can sit from the running binary.

Dossier

Thompson spent most of his career at Bell Labs, where he and Dennis Ritchie built Unix and the C language that carried it. The work is the foundation of a large share of modern computing, from the operating system model to the tools that compile it. His reputation rests as much on economy as on scope: small programs, reused rather than replaced, and a habit of solving the problem at hand with the least machinery that would hold.

The 1984 Turing Award lecture is the clearest statement of his method. In three stages he builds a self-reproducing program, shows a compiler that rewrites its own language, plants a backdoor in the login command, and then hides the planting so that the backdoor survives a rebuild from clean source. The demonstration is small enough to follow in one sitting and broad enough to question what any source review proves.

Later work is just as concrete. With Rob Pike he designed UTF-8, the variable-width encoding that let one byte stream serve both ASCII and the whole of Unicode, an unusual case of a technical standard that spread by being plainly better for the people who had to implement it. Sorting the machinery that shipped from the claims that did not is the useful exercise, and the catalog holds both kinds of record side by side.

Life in order

  1. 1943

    Born in New Orleans

    Thompson is born in New Orleans and grows up in the United States. He takes a bachelor's degree in mathematics and a master's in computer science, the second from the University of California, Berkeley.

  2. 1966

    Joins Bell Labs

    He joins Bell Telephone Laboratories, where he works on the Multics project and meets Dennis Ritchie. The withdrawal of Bell Labs from Multics leaves both men with time, an idle PDP-7, and an interest in building a smaller system.

  3. 1969

    Writes the first Unix

    Thompson writes a small operating system for the PDP-7 so that a game and its development tools can run without Multics. The system is later named Unix, and its file system, shell, and process model become the template for a generation of operating systems.

  4. 1971

    Unix Programmer's Manual, First Edition

    The first manual documents the system in a form short enough to read as a working reference. It fixes the interfaces that later editions keep, and shows the Bell Labs habit of documenting only what the code actually does.

    Manual Unix Programmer's Manual, First Edition, 1971
  5. 1973

    Unix rewritten in C

    Ritchie's C language matures, and the kernel is rewritten in it, so the same source can be moved to a new machine with modest changes. Portability turns a lab system into a candidate for wide use and sets up the self-hosting compiler that the 1984 lecture depends on.

  6. 1974

    The UNIX Time-Sharing System

    Thompson and Ritchie publish a description of Unix in the Communications of the ACM. The paper introduces the design to a wide audience and is the artifact that carries the system past the lab.

    Paper The UNIX Time-Sharing System, 1974
  7. 1975

    Sabbatical sends Unix out

    A teaching year away from Bell Labs puts early Unix copies into a university, where students adapt and redistribute them. The licensing terms of the time let the system travel, and the academic line that becomes Berkeley Unix starts from this period.

  8. 1983

    Turing Award

    Thompson and Ritchie share the ACM Turing Award for the development of a generic operating system theory and the Unix system. He delivers the award lecture the next year, and chooses to talk about compilers rather than Unix.

  9. 1984

    Reflections on Trusting Trust

    The lecture stages a rigged C compiler whose backdoor survives a clean rebuild, then draws a narrow moral about source review and trust. It becomes one of the most cited short papers in software security.

    Paper Reflections on Trusting Trust, 1984
  10. 1992

    UTF-8 with Rob Pike

    Thompson and Pike design a variable-width encoding that keeps ASCII unchanged while covering the whole of Unicode. Its compatibility and simplicity win adoption across operating systems and the early web, and it remains the dominant text encoding.

  11. 2000

    Leaves Bell Labs

    After more than three decades, Thompson retires from Bell Labs and joins a start-up working on network hardware. The move ends the Bell Labs period but not the habit of building small tools close to the machine.

  12. 2007

    Joins Google

    He joins Google, where he works on infrastructure and, with Pike and Robert Griesemer, on the design of a new language. The project is announced in 2009 as Go, and its concurrency model and tooling reflect the same economies he had pursued for decades.

Start with these