Rob Pike: From Unix to Go

Zusammenfassung

Rob Pike spent two decades at Bell Labs as one of the last members of the original Unix circle, building the first window system for Unix, the editors sam and acme, and — with Ken Thompson, sketched on a New Jersey diner placemat in September 1992 — UTF-8, the encoding that now carries virtually all text on the internet. He led Plan 9, the brilliant successor to Unix that the world declined to adopt, then watched its ideas escape into everything from Linux to Docker. At Google he co-created Go, the language born from a 45-minute C++ compile, completing a forty-year lineage of concurrent languages that runs from Tony Hoare’s CSP straight into the engine room of cloud computing. Along the way he co-wrote two of the most respected books in programming and appeared on Late Night with David Letterman as Penn & Teller’s technical assistant.

The Last Generation at Bell Labs

Rob Pike (born 1956 in Canada) studied at the University of Toronto and Caltech before joining Bell Labs’ Computing Science Research Center in 1980 — the legendary “Center 1127” that had produced Unix and C a decade earlier (see The Unix Story: The Operating System That Ate the World). He arrived young enough to be the new generation but early enough to work daily alongside Ken Thompson, Dennis Ritchie, Brian Kernighan, and Doug McIlroy.

Pike’s first major contribution was graphical: in 1981 he wrote the first window system for Unix, and in 1982 he and Bart Locanthi built the Blit, a programmable bitmap graphics terminal that put multiple overlapping windows on a Unix system over a serial line — commercialized by AT&T as the 5620 terminal. His text editors carried that mouse-driven philosophy further: sam (1980s) and acme (early 1990s), the latter a radical environment in which any text on screen — output, file names, commands — is executable or addressable. Both editors retain devoted users today; Pike has remained a career-long contrarian against keyboard-centric orthodoxy, vi and Emacs alike.

With Kernighan he wrote The Unix Programming Environment (1984), the definitive guide to the Unix philosophy, and later The Practice of Programming (1999). His 1989 essay “Notes on Programming in C” distilled his minimalism into Pike’s five rules — culminating in Rule 5, “Data dominates”: choose the right data structures and the algorithms take care of themselves.

Plan 9: Building Unix’s Successor

By the late 1980s, Unix had won — and its creators considered it obsolete. It predated networks, graphics, and multiprocessors, and each had been bolted on. Starting in the late 1980s, Pike, Thompson, Dave Presotto, and Phil Winterbottom — with Ritchie as department head — built a successor from scratch: Plan 9 from Bell Labs, named after the Ed Wood film often called the worst movie ever made.

Plan 9 took Unix’s “everything is a file” credo to its logical conclusion:

Everything really is a file: windows, network connections, processes, even the environment — all are served as files through one protocol, 9P.
Per-process namespaces: every program composes its own view of the system’s resources. A remote machine’s CPU, a colleague’s screen, a network gateway — all mountable into a private file tree.
Designed for networks: CPU servers, file servers, and cheap graphical terminals form one seamless distributed system, decades before “cloud” was a word.

Plan 9 was released to universities in 1992, sold commercially in 1995, and open-sourced in 2000. It was elegant, coherent — and it failed in the market (see the Dead End below).

A Placemat in New Jersey: UTF-8

In September 1992, an X/Open committee asked Pike and Thompson to evaluate a proposed encoding for Unicode text in file systems. The two decided over dinner at a New Jersey diner that they could do better. Thompson worked out the bit-packing on a placemat; the design was self-synchronizing (a reader can find a character boundary from any byte), preserved ASCII unchanged, and never embedded null bytes. They sent the proposal to X/Open on September 8, 1992 — and by the end of that week, Plan 9 was running entirely on the new encoding, becoming the first operating system natively built on it. UTF-8 today encodes the overwhelming majority of all text on the web (the full story: Unicode and UTF-8: The Long Road to a Universal Character Set). Pike later lamented that they hadn’t kept the placemat.

The Concurrency Thread: Squeak, Newsqueak, Limbo

Running through Pike’s entire career is one idea borrowed from Tony Hoare’s 1978 paper Communicating Sequential Processes: programs structured as independent processes talking over channels, rather than threads fighting over shared memory and locks (see Concurrency and Parallelism: Threads, Locks, and the Hard Problem).

Pike built a chain of languages on this idea: Squeak (1985, with Luca Cardelli) for programming graphical user interfaces with concurrent processes, its successor Newsqueak (described in his 1989 paper “Newsqueak: A Language for Communicating with Mice”), then Limbo, the application language of Inferno (1996) — Bell Labs’ compact networked operating system with a virtual machine, conceived for the embedded and set-top-box world and later spun off to the company Vita Nuova. Each iteration refined the same vocabulary: lightweight processes, typed channels, communication as the core primitive. The chain had one more link coming.

Google and Go

Pike joined Google in 2002 (see Google: From Dorm Room to Digital Infrastructure), where he co-designed Sawzall (2005), a language for analyzing logs across Google’s vast clusters. Then, on September 21, 2007, while a large C++ program ground through one of its 45-minute builds, Pike, Robert Griesemer, and Ken Thompson began sketching a new language on a whiteboard.

The result was Go: a language with C’s directness, garbage collection, compilation fast enough to feel interpreted, and — straight from the Squeak–Newsqueak–Limbo lineage — goroutines and channels as built-in concurrency. Go was announced as open source on November 10, 2009, with a mascot, the Go gopher, drawn by the illustrator Renée French — Pike’s wife. Go 1.0 followed on March 28, 2012, with an unusual promise of long-term compatibility. Go became the language of the cloud-native era: Docker and Kubernetes are written in it (the full story: Go: The Cloud-Native Language).

Pike’s design philosophy for Go was the same as for everything he built, summarized in his talk title “Simplicity is Complicated”: features removed, not added; one good way instead of ten configurable ones. Critics called Go primitive; Pike considered that the point.

⚠️ Dead End: Plan 9 and Inferno — The Successors Nobody Wanted

Plan 9 was, by wide consensus, a better design than Unix. It did not matter. By the 1990s, Unix and its clones were good enough, ran everywhere, and carried an enormous ecosystem of software; Plan 9 offered architectural elegance but few applications, few drivers, and no compelling migration path. Eric S. Raymond’s verdict became the standard epitaph: Plan 9 “failed simply because it fell short of being a compelling enough improvement on Unix to displace its ancestor.” Inferno, aimed at the embedded market against Java, fared no better commercially and was sold off in 2000. Pike drew the bitter general lesson in his 2000 talk “Systems Software Research is Irrelevant”: the industry had standardized on Unix and Windows, and no operating-system idea, however good, could any longer reach users as a product.

But as ideas, Plan 9 and Inferno may be the most successful failed systems ever built. UTF-8 conquered the world. Linux adopted Plan 9’s /proc ideas, union mounts, and — crucially — per-process namespaces, the kernel mechanism on which Docker and all Linux containers stand. The 9P protocol ships today inside QEMU and Microsoft’s WSL2. And Go carried Plan 9’s toolchain, its minimalist aesthetic, and Limbo’s concurrency model into one of the most-used languages of the 2020s. The product died; the organs were donated.

Fun Fact: The Magician’s Assistant

In May 1990, Pike appeared on Late Night with David Letterman as the deadpan “technical consultant” to the comedy-magic duo Penn & Teller, who had visited Bell Labs the previous November. A Bell Labs researcher in a lab coat on national television, helping stage a stunt — colleagues reportedly considered it the least surprising thing he ever did.