Go

A programming language designed at Google and released in 2009. Statically typed, compiled, and garbage collected. Known for its pugnacious approach to language design and strong support for concurrency using green threads called goroutines and synchronized queues called channels.

Cheatsheet

Goroutines and channels

// buffer of 100 elements
ch := make(chan int, 100)

x, ok := <-ch // blocks if nothing to read
ch <- x // blocks until read (if unbuffered) or if buffer is full

// non-blocking read
select {
case x, ok := <-ch:
    // ...
default:
    // ...
}

// non-blocking write
select {
case ch <- x:
    // ...
case <-context.Done():
    return
default:
    // ...
}

// wait for goroutines to finish
var wg sync.WaitGroup

wg.Add(1) // outside the goroutine!
go func() {
    defer wg.Done()
    ...
}

wg.Wait()

Cancel a goroutine

doneChannel := make(chan struct{})
go func() {
    time.Sleep(1 * time.Minute)
    close(doneChannel)
}()

go func() {
    for {
        // ...
        select {
        case <-doneChannel:
            return
        default:
            continue
        }
    }
}()

Loops

for my_condition { ... }
for i := 0 ; i < n; i++ { ... }
for i, x := range xs { ... }

Type assertions and switches

s, ok := x.(string)

switch t := x.(type) {
case T1:
    // `t` is value of type `T1`
case T2:
    // `t` is value of type `T2`
default:
    // ...
}

Package organization

• Commands go in cmd/PACKAGE/main.go; private packages go in internal/.

Commands

• go mod init github.com/iafisher/PROJECT
• go get github.com/OWNER/REPO
• go get github.com/OWNER/REPO@none (uninstall)
• go run cmd/server/main.go
• go build -o server cmd/server/main.go
• env GOOS=linux GOARCH=amd64 go build ...
• go test ./...
• go test -test.run FUNC
• dlv debug PKG
• dlv test PKG -- -test.run FUNC

Be careful

• Reading from a closed channel is not an error. Always do v, ok := <-ch!
• break in a select statement breaks out of the select statement itself, not any outer loop.
• If spawning goroutines in a loop, don't do for _, x := range xs { go func() { ... x ... }() } – instead do go func(x T) { ... }(x) to ensure the correct value of x is captured.
• If passing an anonymous function to defer, make sure to call it: defer func() { ... }()
• Indexing a string gives you a byte, not a Unicode character. Use the utf8 package to work with UTF-8 strings.

Posts

• "HTTP servers in Go" (Apr 2025)

Bibliography

Reference and overview:

• Go by Example
• A Tour of Go

Programming practices:

• "One process programming notes (with Go and SQLite)" (David Crawshaw, 2018)
• "Practical Go: Real world advice for writing maintainable Go programs" (Dave Cheney, 2019)
• "Go’s features of last resort" (Martin Tournoij, 2019)
• "On the uses and misuses of panics in Go" (Eli Bendersky, 2018)

Tooling and operations:

• "Building static binaries with Go on Linux" (Eli Bendersky, 2024)
• "Statically compiled Go programs, always, even with cgo, using musl" (Dominik Honnef, 2015)
• "Shrink your Go binaries with this one weird trick" (Filippo Valsorda, 2016)

Concurrency:

• Channel/goroutine behavior by example
• "Go Concurrency Patterns: Context" (Sameer Ajmani @ The Go Blog, 2014)
• "Go Concurrency Patterns: Pipelines and cancellation" (Sameer Ajmani @ The Go Blog, 2014)
• "Understanding Real-World Concurrency Bugs in Go" (Tengfei Tu et al, 2019)
• "Go hits the concurrency nail right on the head" (Eli Bendersky, 2018)
• "Why you can have millions of Goroutines but only thousands of Java Threads" (Russell Cohen, 2018)
• "Data Race Detector"

Language comparisons:

• "Einstein Analytics and Go" (Guillaume Le Stum @ Stack Overflow, 2019) – rewriting a backend from Python to Go
• "Why Go and not Rust?" (Loris Cro, 2019)

Language evolution:

• "Go 2 Draft Designs"
• "Backward Compatibility, Go 1.21, and Go 2" (Russ Cox, 2023)

Internals:

• "Go channels on steroids" (Dmitry Vyukov, 2014)
  • chan.go – the actual implementation of channels
• "The Go runtime scheduler's clever way of dealing with system calls" (Chris Siebenmann, 2019)
• "Go's work-stealing scheduler" (rakyll, 2017)
• "The Go scheduler" (Daniel Morsing, 2013)
• "The Go netpoller" (Daniel Morsing, 2013)
• • "The Go runtime scheduler's clever way of dealing with system calls" (Chris Siebenmann, 2019)
• "Some reasons for Go to not make system calls through the standard C library" (Chris Siebenmann, 2019)
• "Go compiler internals: adding a new statement to Go - Part 1" (Eli Bendersky, 2019)
• "Proposal: Register-based Go calling convention" (Austin Clements, 2020)
• "Getting to Go: The Journey of Go's Garbage Collector" (Rick Hudson, 2018)

Commentary:

• "Go at Google: Language Design in the Service of Software Engineering" (Rob Pike, 2012)
• "Go is Google's language, not ours" (Chris Siebenmann, 2019)
• "Ten Reasons Why I Don't Like Golang" (Lawrence Kesteloot, 2016)
• "I want off Mr. Golang's Wild Ride" (fasterthanlime, 2020)
• "Go Is a Shop-built Jig" (Rob Napier, 2014)
• "The Value in Go's Simplicity" (Ben Congdon, 2019)