A System Should Be Small Enough to Hold Completely in One's Head

Thompson's design philosophy: the best system is one that can be completely understood by a single experienced person. Unix's initial kernel was extremely small; every component's responsibility could be completely described. This 'understandability' is the core metric of system excellence.

Source: The Unix Time-Sharing System, Ritchie and Thompson, Communications of the ACM, 1974 / Rob Pike interview on Ken Thompson's design philosophy, informit.com, 2012

You Cannot Trust Code You Did Not Totally Create Yourself

Thompson argued in his 1983 Turing lecture 'Reflections on Trusting Trust': a compiler can have a backdoor implanted that cannot be detected by inspecting the source code, revealing the fundamental vulnerability of the entire computer trust chain.

Source: Reflections on Trusting Trust, Ken Thompson, Communications of the ACM, Vol. 27, No. 8, August 1984

The Second Time Will Be Better; Don't Fear Rebuilding

Unix was the 'second attempt' after Multics' failure — simpler, faster, more practical. Thompson's B language paved the way for C; Go is Thompson's 'fiftieth rebuild' of C/C++ problems. Important systems often require failed predecessor versions.

Source: Ken Thompson interview, The Go Programming Language, gopl.io, 2015

Language Complexity Is the Greatest Long-Term Maintenance Risk

In Go's design, Thompson insisted on removing many C++ features (generics were initially rejected, no inheritance, no exceptions), aiming for every Go programmer to be able to read and understand the entire codebase. Complex language features are the primary source of system decay.

Source: The Go Programming Language, Alan A. A. Donovan and Brian W. Kernighan, Addison-Wesley, 2015 / Go FAQ: Why does Go not have feature X?, golang.org/doc/faq

Head-Holdable System Design

System complexity should not exceed what a single experienced engineer can hold completely in their head; otherwise the system's long-term evolution will become uncontrollable.

Early Unix kernel had only a few thousand lines of code; an experienced programmer could read and understand the entire kernel in a few days — making debugging, porting, and evolution extremely efficient.

Trust Chain Security Model

The fundamental problem of software security is the trust chain — every component you trust must be independently verified, otherwise the security of the entire system cannot be guaranteed.

Thompson demonstrated in his Turing lecture: even by examining C compiler source code, a carefully designed backdoor cannot be found, because the backdoor can be carried by the compiler itself. This is known as the 'Thompson hack'.

Language Minimization Principle

Programming language features should be strictly filtered, retaining only necessary features with sufficient validation; remove any feature whose value cannot be simply explained.

Go rejected inheritance, exceptions, and method overloading from C++/Java; every retained feature was thoroughly discussed by the three founders.

Bell Labs Unix Creation Era

1966-1978

Creating Unix and B language, laying the foundation of modern operating systems

After joining Bell Labs, Thompson participated in Multics, then co-invented Unix with Ritchie. He designed B language (a BCPL derivative), the direct predecessor of C. Unix's core file system and shell design were primarily completed by Thompson, while Ritchie focused on C implementation.

Bell Labs Mature Research Era

1978-1997

Unix ecosystem building after Turing Award and Plan 9 research

The 1983 Turing Award was the peak of this period. Afterward, Thompson participated in developing Plan 9 OS (a modern extension of Unix design philosophy). Plan 9 introduced some concepts that later influenced Go. In 1992, he and Rob Pike co-invented the UTF-8 character encoding standard.

Entrust/Bell Labs Late Era

1997-2006

Research continuation after Bell Labs restructuring, Inferno OS

After Bell Labs was acquired by Lucent and restructured multiple times, Thompson continued participating in Inferno OS development. This period was relatively quiet, but accumulated thinking on next-generation system design for his later Google work.

Google/Go Language Creation Era

2006-至今

Co-designing the Go language at Google, injecting Unix simplicity philosophy into modern systems programming

Thompson joined Google at 63 and began designing Go with Rob Pike and Robert Griesemer (started 2007, open-sourced 2009). Go's simplicity, efficient concurrency (goroutines), and fast compilation directly embody Thompson's design philosophy — the culmination of 40 years of systems design thinking.