Go, or how a forty-five-minute build became a programming language
Rob Pike, Robert Griesemer, and Ken Thompson did not set out to redesign systems programming on September 21, 2007. They just needed something to do while a C++ build finished. The build took forty-five minutes. Go took somewhat longer — though the core design landed on a Google whiteboard that same afternoon.
The frustration was specific. Google’s engineers were maintaining codebases stretching to tens of millions of lines, and the C++ builds had grown so entangled — header files pulling in header files — that even with distributed build systems, a full compile could eat most of a morning. Skilled engineers, Pike and colleagues observed, were quietly abandoning C++ for Python or JavaScript: trading type safety and performance for languages that didn’t make them wait. Go was an attempt to make that trade unnecessary.
The three of them brought credentials to the problem. Pike and Thompson had co-designed Unix and Plan 9 at Bell Labs; Griesemer had worked on V8 and the Hotspot JVM. Between them they had a working theory about where C++ had gone wrong: too complex, too slow to compile, too hostile to the multicore processors that were multiplying across server racks faster than the language ecosystem could use them.
What they built was deliberately small. Go has garbage collection but no templates, objects but no inheritance, and a type system strict enough to catch mistakes and legible enough to understand before lunch. Its signature contribution is the goroutine — a lightweight thread managed by the Go runtime rather than the operating system. Where an OS thread consumes megabytes of stack space, a goroutine starts at about two kilobytes. A single program can run hundreds of thousands of them concurrently. Goroutines communicate through channels, passing data rather than sharing memory — a model borrowed from Tony Hoare’s 1978 paper on Communicating Sequential Processes, which had been waiting thirty years for hardware fast enough to make it practical.
Go went public on November 10, 2009. The Google open-source blog post announcing it was headlined “Hey! Ho! Let’s Go!” — a Ramones lyric that says more about the team’s mood than their marketing instincts. The gopher mascot, a cartoonish illustration by designer Renée French adapted from a radio-station T-shirt, arrived the same day and has outlasted most tech logos of its era.
The core promise was a compile that felt “instantaneous.” On the hardware of 2009, large Go binaries compiled in seconds. Engineers who had built habits around waiting — browser tabs open, coffee brewed, attention scattered — found the feedback loop suddenly tight again.
Go 1.0 landed in March 2012 with a compatibility guarantee: code written for 1.0 would compile unchanged under every future release. That promise, boring and bureaucratic and enormously important, anchored Go into critical infrastructure. Docker was written in Go and announced in 2013. Kubernetes followed in 2014. So did Terraform, Prometheus, and CockroachDB — the scaffolding of the modern cloud, most of it compiled in seconds from a language sketched on a whiteboard during a build wait.
The binary eventually finished. Its descendants are still running.
Sources
- Go (programming language) — Wikipedia — history, goroutines and channels, September 2007 origin, Go 1.0 release date, Docker and Kubernetes built in Go
- Hey! Ho! Let’s Go! — Google Open Source Blog — original November 2009 announcement, team members, “instantaneous builds” promise
- The Birth of Go — albertbf.com — September 21, 2007 whiteboard session, Pike’s “origin myth” clarification, the 45-minute compile as design motivation