iTranslated by AI
Children of the Namespace: A Genealogy of Plan 9 and Go
Plan 9 is dead. But its language drives the world.
Many people write Go. But how many know where Go came from?
The design of goroutines and channels dates back to Hoare's CSP theory from 1978 and is the culmination of a concurrency model that Rob Pike experimented with repeatedly through Newsqueak (1988), Alef (1992), and Limbo (1995). The Go compiler is a direct descendant of the C compiler Ken Thompson wrote for Plan 9. The type name rune was brought in directly from the terminology for UTF-8 code points born in Plan 9, and the design decision that Go's string is a sequence of UTF-8 bytes is connected in a single line to the moment Pike and Thompson invented UTF-8 on a diner placemat in 1992.
Go's origins lie in Plan 9. And Plan 9 is the OS designed by the people who created Unix to "do Unix over."
This book, "Children of the Namespace: The Lineage of Plan 9 and Go," is a history of technology and design philosophy that starts with the design philosophy of the OS called Plan 9, born at Bell Labs, and traces how it was inherited by the Go language. I will be writing and publishing it as a series of articles or a book.
Table of Contents
Part I: The Fathers' Design
Chapter 1: The Planet of Bell Labs
The culture and atmosphere of Bell Labs. Thompson, Ritchie, Pike, Kernighan. The "coexistence of utility and aesthetics" produced by the institution of the laboratory.
Chapter 2: The Success and Discontent of Unix
The limitations the designers themselves felt as Unix spread. The contradiction between the ideal of "everything is a file" and reality.
Chapter 3: The Birth of Plan 9
The late 1980s project to "do Unix over." Namespaces, the 9P protocol, rfork.
Chapter 4: UTF-8 — A Weekend Invention
September 1992, the encoding Pike and Thompson wrote on a placemat. From Plan 9 to a global standard.
Part II: The Kingdom of Namespaces
Chapter 5: Everything is a File, This Time for Real
The thorough implementation of namespaces in Plan 9. /proc, /net, /dev. The essential differences from Unix.
Chapter 6: 9P — The Universal Protocol of Files
The design of the 9P protocol. Plan 9 as a distributed system.
Chapter 7: Processes and Concurrency — From rfork to CSP
Plan 9's process model. Hoare's CSP theory. Experiments in Newsqueak.
Chapter 8: The Language Called Alef
The vision of C + CSP. Why Alef did not succeed and the legacy it left behind.
Chapter 9: rio, acme, sam — The Philosophy of Interfaces
Interfaces as text protocols rather than GUIs. The philosophy of the "OS as a tool."
Part III: The Forgotten OS
Chapter 10: Why Didn't Plan 9 Become Popular?
The structural reasons why a technically superior OS failed in the market. The rise of Linux, the transformation of Bell Labs.
Chapter 11: Inferno — Reincarnation as a Virtual Machine
An attempt to make Plan 9's philosophy portable. The Dis virtual machine and the Limbo language.
Chapter 12: Limbo — Go's Closest Ancestor
A detailed reading of Limbo's language design. A step-by-step comparison of similarities and differences with Go.
Part IV: The Children's Language
Chapter 13: September 2007 — The Inspiration for Go
The language design started by Griesemer, Pike, and Thompson at Google. Anger at C++ and memories of Plan 9.
Chapter 14: Goroutines and Channels — The Final Form of CSP
Newsqueak → Alef → Limbo → Go. A history of the evolution of the concurrency model.
Chapter 15: From Namespaces to Packages
How Plan 9's namespaces were transformed into Go's package system.
Chapter 16: The Lineage of Compilers
The direct genealogy from the Plan 9 C compiler to the Go compiler.
Chapter 17: Rune and String — The Homecoming of UTF-8
The story of how UTF-8, born in Plan 9, returned as Go's string and rune types.
Chapter 18: Ghosts of Plan 9 — Walking Through Go's Standard Library
os/exec, net, io, context. An archaeological exploration to excavate the "invisible Plan 9."
Part V: Beyond the Lineage
Chapter 19: What Go Did Not Inherit
Philosophies that existed in Plan 9 but did not come to Go. Intentional disconnection or constraints of the times?
Chapter 20: The Lineage Continues
9front, Harvey OS. TinyGo, Wasm. Where will Plan 9's genes head next?
Concluding Chapter: The Future of Namespaces
Variations of namespaces in the age of containers, microservices, and AI.
Why I am writing this book
There are few comprehensive texts on Plan 9 written in Japanese. Moreover, there is almost no book, even in the English-speaking world, that depicts the inheritance of design philosophy from Plan 9 to Go as a single historical narrative.
Go is called a "simple language." But that simplicity is a distillation of 30 years of trial and error. Knowing that process should serve as a helpful guide not only for using Go better but also for thinking about software design philosophy itself.
Updates to the series will be irregular. I hope you will join me patiently.
Discussion