Why Google Created the Go Language in 2007

Go, often called Golang, is a compiled, statically typed language that Google announced as open source in November 2009. The design itself started two years earlier. Why Google created the Go language in 2007 comes down to everyday pain: huge C++ codebases that took ages to build, tangled dependencies, and server software that needed to use many CPU cores without turning into a threading nightmare.

Why Google created the Go language in 2007

In September 2007, three Google engineers began sketching a new language on a whiteboard: Robert Griesemer, who had worked on the Java HotSpot VM and the V8 JavaScript engine; Rob Pike, of Bell Labs, Plan 9 and UTF-8 fame; and Ken Thompson, co-creator of Unix and the B language. Pike has described the starting point as waiting for a large C++ build to finish and asking why things had become so complicated.

Their goals were concrete:

• Fast compilation, even for very large programs, by designing the dependency model carefully.
• Simple, readable code that a big team can maintain, with a small specification and few ways to do the same thing.
• Built-in concurrency suited to networked servers on multicore machines.
• Garbage collection and memory safety without the weight of a virtual machine.

Ian Lance Taylor, who wrote the gccgo compiler, and Russ Cox joined early and became central to the project. Go 1.0 shipped in March 2012 with the Go 1 compatibility promise: code written for Go 1 should keep compiling with later 1.x releases.

Design and key features

• Goroutines: very cheap concurrent functions started with the go keyword and scheduled by the runtime.
• Channels for communication between goroutines, an idea rooted in Tony Hoare's CSP and in Pike's earlier languages Newsqueak and Limbo.
• Implicit interfaces: a type satisfies an interface just by having the right methods, with no implements keyword.
• Composition over inheritance, using struct embedding instead of class hierarchies.
• Errors as values, handled explicitly, plus defer for cleanup.
• Single static binaries that are easy to copy into a container.
• Tooling in the box: gofmt, go test, go vet, the race detector and profiling.

A short Go example

Three goroutines share a job queue through channels, and a WaitGroup waits for them to finish:

package main

import (
	"fmt"
	"sync"
)

func worker(id int, jobs <-chan int, results chan<- string, wg *sync.WaitGroup) {
	defer wg.Done()
	for n := range jobs {
		results <- fmt.Sprintf("worker %d: %d squared is %d", id, n, n*n)
	}
}

func main() {
	jobs := make(chan int, 5)
	results := make(chan string, 5)
	var wg sync.WaitGroup

	for i := 1; i <= 3; i++ {
		wg.Add(1)
		go worker(i, jobs, results, &wg)
	}
	for n := 1; n <= 5; n++ {
		jobs <- n
	}
	close(jobs)

	wg.Wait()
	close(results)
	for r := range results {
		fmt.Println(r)
	}
}

Versions and milestones

New versions arrive roughly every six months, in February and August.

Where Go is used today

Go became the language of cloud infrastructure. Docker (2013) and Kubernetes (2014) are written in Go, as are Terraform, Prometheus, etcd, Consul, CockroachDB, Caddy and the Hugo static site generator. Google, Uber, Cloudflare, Twitch and many others use it for back-end services, command-line tools and network proxies. The gopher mascot, drawn by Renée French, is one of the best-known logos in programming.

Influence

Go's biggest influence may be cultural. gofmt made a single, automatic code style normal, and later languages copied the idea with tools like rustfmt and Prettier. Its fast builds, static binaries and simple deployment set expectations for newer languages such as Crystal, V and Odin.

Should you learn Go?

If you work on back-end services, DevOps tooling or anything that runs in containers, Go is one of the most useful languages you can learn. You can read most of the specification in an evening and be productive within weeks. Knowing why Google created the Go language in 2007 also explains its trade-offs: it deliberately gives up some expressiveness so that large teams can read, build and maintain code quickly.

Frequently asked questions

Who invented the Go programming language?

Go was designed at Google by Robert Griesemer, Rob Pike and Ken Thompson, starting in September 2007. Ian Lance Taylor and Russ Cox joined early and made major contributions, and the language is now developed in the open with a large community.

Why did Go take so long to add generics?

The Go team was not against generics but could not find a design that kept the language simple and compilation fast. After several rejected proposals, type parameters arrived in Go 1.18 in March 2022.

Is Go a replacement for C++?

For network services and tools, Go replaced C++ in many teams, which was part of the original goal. For game engines, operating system kernels or code that cannot tolerate a garbage collector, C++ and Rust remain more common choices.