Go: A Documentary

by Changkun Ou <changkun.de> (and many inputs from contributors)

This document collects many interesting (publicly observable) issues, discussions, proposals, CLs, and talks from the Go development process, which intents to offer a comprehensive reference of the Go history.

Disclaimer

Sources

There are many sources for digging the documents that relate to Go's historical design, and here are some of the official sources:

Origin

Go is a big project driven by a tiny group of people and the crowd of wisdom from the language user community. Here are some core committers to the project that you might interest in following their excellent work.

Go's origin is attractive without doubts. By listening to the talks held by these people, you could learn more about their oral history and fun stories behind the great work.

For instance, here are some exciting talks regarding the historical feats in Go might be your starting points (as a subjective recommendation): talk/rob2007, talk/rob2009, talk/rob2010b, talk/rob2010d, talk/rob2011a, talk/rob2013a, talk/rob2019, talk/robert2015, talk/russ2014, steve2019b, etc.

Committers

Core Authors

The Go was created by Rob, Robert, and Ken initially because Rob were suffered by the slow C++ compiling time, talked to Robert, and luckily Ken was in the next office. Later, Ian joined the project since he showed huge interests and wrote the gccgo. Rob and Ken are retired. Robert and Ian currently work on adding generics to Go. Russ is also one of the core authors of the project in the early stage. Back then, he was a newcomer at Google, and Rob invited Russ for joining the Go team since he knew Russ from way back because of the Plan 9 project. Russ did many fundamental work for the early Go compiler, runtime, as well as the leap of Go 1.5 bootstrap. Now, Russ is the tech leader of the Go team.

Compiler/Runtime Team

Dmitry is not from the Go team but on the dynamic testing tools team from Google. He wrote the scalable goroutine scheduler, many other performance improvements, synchronization primitives, race detector, and blocking profiler that related to the Go runtime. Austin was an intern at Google who worked on the Go project in the early days while pursuing a Ph. D. Later, he joined the Go team after his academic career and work together with Rick for the Go's concurrent GC. He also worked on the current preemptive scheduler and linker. Now, he is leading the Compiler/Runtime team for Go. Keith and David together focus on the Go's compiler backend, notably the current SSA backend. Michael is a recent newcomer to the Go team, his work mainly in the runtime memory system such as the refactoring of memory allocator and runtime metrics.

Library/Tools/Security/Community

more people and talks should be added...

Group Interviews

Timeline

A timeline helps you identify the point in time about a document that is reflected in Go versions.

Version Release Date
Go 1 2012.03.28
Go 1.1 2013.05.13
Go 1.2 2013.12.01
Go 1.3 2014.06.18
Go 1.4 2014.12.10
Go 1.5 2015.08.19
Go 1.6 2016.02.17
Go 1.7 2016.08.15
Go 1.8 2017.02.16
Go 1.9 2017.08.24
Go 1.10 2018.02.16
Go 1.11 2018.08.24
Go 1.12 2019.02.25
Go 1.13 2019.09.03
Go 1.14 2020.02.25
Go 1.15 2020.08.11

The historical release notes may helpful for general information:

Language Design

Misc

Slice (1.2)

Package Management (1.4, 1.5, 1.7)

Type alias (1.9)

Defer (1.13)

Error values (1.13)

Channel/Select

Generics

Compiler Toolchain

Compiler

Linker

The Go Linker was written by Ken Ken Thompson. Russ led a few more overhaul in Go 1.3. Austin led a rework to the linker together with Keith, Than, Cheery and many other brilliant brains, which was landed in Go 1.15 and Go 1.16.

Debugger

Race Detector

Tracer

Lock Analysis

Builder

Modules

gopls

Testing

Runtime Core

Scheduler

Execution Stack

Memory Allocator

A quick history about the Go's memory allocator: Russ Cox first implements the memory allocator based on tcmalloc for Go 1, mcache is cached on M. Then he revised the allocator to allow user code to use 16GB memory and later allows 128GB. However, the allocator (including scavenger) was suffered from massive lock contentions and does not scale. After Dmitry's scalable runtime scheduler, the allocator can allocate directly from P (with much less) lock contentions. In the meantime, the scavenger is migrated from an independent thread into the system monitor thread. Now, Michael is actively working on improving the memory allocator's scalability, such as migrating scavenger to user threads, bitmap-based page allocator, scalable mcentral.

Garbage Collector

Statistics

Memory model

Go memory model is not well defined (yet), but atomic is likely to guarantee sequential consistency.

ABI

Standard Library

syscall

os, io, io/fs, embed

In Go 1.16, tons of major rework and improvements surrounds the new os/fs package.

go/*

sync

Map

Pool

Mutex, RWMutex

Groups

atomic

time

context

encoding

image, x/image

The following issues are surrounding by the color management of the image standard library. At the moment, Go's image library doesn't read or write meta information from an image in the encoding or decoding phase. Therefore the color information could go wrong while processing an image such as scaling in a non-linear sRGB space. A universal solution is to design image metadata APIs to aware the color profile in an encoded image file.

misc

Fun Facts

Acknowledgements

The document author would like to first thank the TalkGo community creator Mai Yang's champion sponsorship for the golang.design initiative. His creation of the TalkGo significantly changed the Go community in China. He is also a great person that is actively contributing to all kinds of Go related projects.

It is also important to thank the continuing, inspiring discussion and sharing with the TalkGo community core members qcrao, and eddycjy.

The document would not be organized without all of the supports from them.

License

golang.design/history | CC-BY-NC-ND 4.0 © changkun