The Origins of Go: Simplicity as a Feature

Matt George

Fractional CTO · Founder of Injuria.ai

•8 min read•

Most languages try to add power by adding features. Go went the other direction. Its creators believed that the real problem in large-scale software was not a shortage of language features but an excess of them, along with the slow builds and hard-to-read code that came with that excess.[1] So they built a language defined as much by what they left out as by what they put in. That discipline looked almost stubborn at first. It turned out to be exactly what a generation of cloud infrastructure needed.

Three veterans and a slow build

Go began at Google in 2007 and was announced publicly in 2009.[2][9] Its designers were not newcomers. Robert Griesemer had worked on the V8 JavaScript engine and the HotSpot Java virtual machine. Rob Pike and Ken Thompson were giants from Bell Labs, where Thompson had co-created Unix and written the B language, a direct ancestor of the C that Dennis Ritchie built next door.[9] Pike had worked on Plan 9 and co-designed the UTF-8 encoding that now represents text across the entire web.

The origin story the team tells is almost mundane, which is part of its charm. They were waiting for a large C++ program at Google to compile, a wait that could stretch to many minutes, and they started sketching a language that would not make them wait.[1] Google's scale had turned ordinary problems, build times, dependency management, and onboarding new engineers onto a huge codebase, into serious drags on productivity. Go was aimed squarely at those. It is worth sitting with that for a second: Go was not designed to be beautiful or clever, it was designed to make a large organization of ordinary engineers productive on a shared codebase, and almost every one of its controversial choices makes sense the moment you accept that goal.

Simplicity as the design goal

Go's defining choice is its smallness. The language specification is short enough to read in an afternoon.[7][10] For years it deliberately omitted features that most modern languages considered essential, including generics, exceptions in the usual sense, and class inheritance. The reasoning was that a small language is easier to learn, easier to read, and easier for a large team to maintain, because there are fewer ways to express the same idea and fewer clever tricks to decode in someone else's code.

The team enforced consistency with tooling. The gofmt tool formats all Go code to one standard style, which ended formatting debates permanently. There is a single way Go code looks, and everyone uses it. People new to Go often resent this, then quietly come to love it, because it means you never spend a code review arguing about braces.

Interfaces and errors, the two choices that define the culture

Two decisions do more than any other to make Go code look and feel the way it does, and the draft version of this story usually skips both.

The first is implicit interfaces. Go has no class inheritance. Instead, a type satisfies an interface simply by having the right methods, with no declaration that it intends to.[4] A function that needs "something I can read bytes from" accepts anything with a Read method, whether the author of that type ever heard of your function or not. This is structural typing, and it gives Go polymorphism and decoupling without the deep class hierarchies that make large object-oriented codebases hard to move through.

The second is error handling, and it is the most polarizing thing about the language. Go has no exceptions for ordinary failures. Functions return an error value alongside their result, and you check it explicitly.

f, err := os.Open(name)
if err != nil {
    return err
}

Critics count the if err != nil lines and call it noise. I used to agree, and I no longer do. The verbosity is the point. Every place a Go program can fail is visible on the page, in line, instead of hidden in an invisible path that unwinds the stack. It makes reading unfamiliar Go slower to write and much easier to trust, which is the exact trade a large infrastructure team wants.

Concurrency built in

The one area where Go was generous rather than sparing is concurrency, and it reflects Pike and Thompson's background. Go makes it cheap to run many tasks at once through goroutines, lightweight threads managed by the Go runtime rather than the operating system. You can run hundreds of thousands of them. Goroutines coordinate through channels, following the maxim "do not communicate by sharing memory; share memory by communicating."[5][11] That is a strong cultural default rather than a hard rule, and when you genuinely need a plain lock, the standard library's sync package has one. Starting concurrent work is almost trivial.

go handleRequest(conn)

That single keyword launches a function as a goroutine. For software that spends its life handling many network connections at once, which describes most web servers and infrastructure tools, this model is a natural fit and a large part of Go's appeal.[12] Making it work at scale also required an unusually good garbage collector, one tuned for low pause times rather than raw throughput, so that a server juggling thousands of connections never freezes for long. The team's multi-year effort to get collection pauses down into the sub-millisecond range is one of the quiet engineering achievements that made Go viable for serious network services.[6][11]

One binary, easy deploys

Go compiles to a single executable. For pure Go code that binary is fully self-contained, with no interpreter or virtual machine to install on the server. You build, you copy one file, you run it. After years of wrestling with runtimes and dependency hell, operations teams found this deeply refreshing. The one asterisk is that programs which reach into C libraries can end up dynamically linked, but most Go services build to a static binary and drop into a container that is little more than that single file.

Dependency management took longer to get right than anything else. For most of a decade Go relied on a scheme called GOPATH that most newcomers found baffling, and reproducible builds were genuinely hard. Go Modules, introduced at the end of the 2010s with a go.mod file per project, finally fixed it. That it took that long is a theme worth noticing: Go moves slowly and changes little, which is a cost when the language is missing something and a benefit for everyone who has to run its code for years.

The language of the cloud

Go's real-world victory came in infrastructure. Docker, which popularized containers, is written in Go. So is Kubernetes, the system that orchestrates containers at scale and now anchors much of cloud computing. Terraform, Prometheus, etcd, and a long list of other foundational tools are Go programs. When the industry rebuilt itself around containers and cloud-native patterns in the 2010s, it largely built that new layer in Go. The fast builds, easy deployment, and cheap concurrency were ideal for exactly that work, and once the foundational tools were in Go, every team extending them reached for Go too.

The generics holdout

Go's commitment to simplicity was tested for more than a decade by one argument: whether to add generics, which let you write code that works across many types without duplication. Users asked repeatedly. The team held out, unwilling to add the feature until they had a design that fit the language's spirit, and generics finally arrived in Go 1.18 in 2022.[8] The long wait is the clearest window into the culture. The bar for adding anything to Go is deliberately punishing, and the default answer is no. That is maddening when you want the feature and reassuring when you are maintaining a million lines someone else wrote.

Subtraction as a strategy

Go reached its 1.0 release in 2012 with a promise of long-term compatibility that it has honored ever since, and that promise is a feature in its own right.[3] Code written for Go 1.0 still compiles today, which is why companies trust it for the plumbing they cannot afford to rewrite every few years. The whole language is an argument that most people get backwards: that saying no to features, to cleverness, to the newest idea, is not conservatism but design. Go is not the language you reach for to express something elegantly. It is the language you reach for when ten people need to maintain the same service for a decade, and on that specific and unglamorous goal, nothing else comes close.

Sources (12)
  1. Pike, Griesemer, Taylor, "Go at Google: Language Design in the Service of Software Engineering"
  2. Google Open Source Blog, "Hey! Ho! Let's Go!" (2009 announcement)
  3. The Go Blog: Go version 1 is released (2012)
  4. Effective Go (official documentation)
  5. The Go Blog: "Share Memory By Communicating"
  6. The Go Blog: "Getting to Go: The Journey of Go's Garbage Collector"
  7. The Go Programming Language Specification
  8. The Go Blog: Go 1.18 is released (generics)
  9. Mihalis Tsoukalos, Mastering Go (Packt Publishing Ltd, 2024)
  10. Alan A. A. Donovan, Brian W. Kernighan, The Go Programming Language (Addison-Wesley Professional, 2015)
  11. Bob Strecansky, Hands-On High Performance with Go (Packt Publishing Ltd, 2020)
  12. George Ornbo, Go in 24 Hours, Sams Teach Yourself (Sams Publishing, 2017)

Recommended reading

The Origins of TypeScript: Adding a Type System to JavaScript7 min readJavaScript's flexibility is a gift on a small page and a liability in a large codebase. TypeScript was Microsoft's answer: keep the language, add a type system on top. Here is where it came from and why it won when every earlier attempt failed.The Origins of Java: Write Once, Run Anywhere7 min readJava was built to run on television set-top boxes. That market never arrived, but the idea underneath it, code that runs anywhere without changes, made Java the language of enterprise software and Android. Here is the story.The Origins of PHP: The Accidental Language That Runs Much of the Web6 min readPHP was never meant to be a programming language. It started as a few tools one developer wrote to track visits to his resume, survived an existential threat from Facebook, and still runs a large share of the web. Here is how.The Origins of Ruby: A Language Designed for Programmer Happiness6 min readMost languages optimize for the machine or the problem. Ruby set out to optimize for the person writing the code. That unusual goal, plus one framework, turned it into the language behind a generation of startups.The Origins of C#: Microsoft's Answer to Java5 min readC# was born out of a lawsuit. Blocked from extending Java, Microsoft built its own modern language, had it standardized so no one could call it a cage, and spent two decades turning it into a fast, open, cross-platform tool.The Origins of SQL: The Language That Refused to Die6 min readSQL is more than fifty years old, has been declared obsolete more than once, and still runs the data layer of nearly every web application. Here is where it came from, the rival language it beat, and why nothing has managed to replace it.