Go,
the language and the runtime.

Why Go.

Go is what you reach for when you want a single static binary, fast compile times, and concurrency that does not destroy you. It is small. The spec fits in a long evening. The tooling is in the box. There is one formatter, one linter, one test runner, and one build system — all named go. The cost: the language refuses features other languages take for granted (no exceptions, no inheritance, no operator overloading, no generic methods). The benefit: a Go codebase you have not seen before is legible in five minutes.

The runtime is the second half of the story. The GMP scheduler multiplexes hundreds of thousands of goroutines onto a small set of OS threads. The garbage collector keeps stop-the-world pauses under a millisecond at almost every heap size. The toolchain knows how to cross-compile to anything, profile anything, and fuzz anything. None of these required you to install a plugin.

When not to use Go. Hard real-time (the GC, even sub-ms, is not zero). Numerical computing where SIMD-heavy libraries dominate (Rust + portable-simd is closer). Code where exhaustive enum matching matters (sum types are not idiomatic in Go). Anything that has to ship as a library to a non-Go runtime — Go's runtime ships with the binary and is not pleasant to embed.

The twelve mental models you must build.

These twelve concepts cover ~95% of the language and runtime surface. Get them in your bones in the first two weeks; the rest is library API. The runtime-tier ones (GC, escape analysis) come later but pay back enormously.

Day-zero — your first hour.

One hour. Install the toolchain, write the canonical "echo server", run the race detector against it. You'll have exercised six of the twelve mental models by the end.

# 1. Install Go (any platform)
brew install go              # macOS
sudo apt install golang-go   # Debian / Ubuntu
# or download from https://go.dev/dl/

go version
# go version go1.22.x linux/amd64

# 2. New module, single file
mkdir hello && cd hello
go mod init example.com/hello
cat > main.go <<'EOF'
package main

import (
    "fmt"
    "net/http"
    "sync/atomic"
)

func main() {
    var n int64
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        c := atomic.AddInt64(&n, 1)
        fmt.Fprintf(w, "request #%d: %s %s\n", c, r.Method, r.URL.Path)
    })
    fmt.Println("listening on :8080")
    http.ListenAndServe(":8080", nil)
}
EOF

# 3. Run it
go run main.go
# in another terminal:
curl localhost:8080/foo

# 4. Build a static binary
go build -o hello

# 5. Race detector — every Go programmer's first habit
go run -race main.go

# 6. Cross-compile to Linux from anywhere
GOOS=linux GOARCH=amd64 go build -o hello-linux

Done. You've used the toolchain, the module system, the standard library's net/http, atomic operations, and the race detector. The next step is muscle memory.

Day-1 to Day-7 — the muscle memory.

Seven days, ~30–60 minutes each. Each day adds one capability. By Friday you can ship a Go service.

Week-1 to Month-3 — pick a track.

After week one you can read most Go you encounter. The next two months should be one track at a time, depth-first. Don't try to learn the runtime and the standard library in the same fortnight.

The runtime — read the source.

The Go runtime is roughly 60,000 lines of Go (with a small amount of assembly per architecture) and lives in src/runtime/. It is exceptionally well-commented. Once you can read it, "what does my goroutine actually do" stops being a mystery.

The four files worth reading first, in order:

runtime/proc.go

The GMP scheduler. Goroutines (Gs), OS threads (Ms), processors (Ps). Work stealing. Park / unpark. The single most important file in the runtime.

runtime/mgc.go

The concurrent tri-color mark-sweep GC. The pacer (how it decides when to run). Write barriers. The reason your STW pauses are sub-ms.

runtime/chan.go

Channels. The hchan struct, the sudog wait queue, the send/receive fast paths and slow paths. Reading this for an hour replaces a year of confused use.

runtime/netpoll.go

The platform-specific I/O multiplexer (epoll on Linux, kqueue on BSD/macOS, IOCP on Windows). How net.Conn.Read parks a goroutine without parking its M.

The runtime is also where GODEBUG lives. Setting GODEBUG=schedtrace=1000,gctrace=1 on a running binary prints scheduler and GC events as they happen. Read the output once and the runtime stops being abstract.

A second-pass tour, after you've read the four files: Russ Cox's Go's GMP scheduler talk (2018), Vyukov's original work-stealing scheduler design doc, and the GC pacer redesign blog post by Michael Knyszek (2022).

The four books that matter.

Honourable mentions: Go in Action (Kennedy), The Go Workshop (Quinn et al), and Jon Bodner's Learning Go 1st edition (still excellent if you can find it cheap).

Courses, tutorials, and interactive learning.

• go.dev
  A Tour of Go
  The official interactive tour. ~90 minutes. Run snippets in the browser, modify, re-run. The standard intro.
• go.dev
  Effective Go
  The "how to write idiomatic Go" document. Reads like a style guide written by the language designers, because it is.
• Mark McGranaghan
  Go by Example
  A reference of small annotated programs covering most of the language. Faster than the spec when you've forgotten how channels work.
• Exercism
  Go track
  ~100 exercises with mentor feedback. The right shape for "I want to actually write some Go before I read more".
• JustForFunc
  Francesc Campoy's video series
  Long-form Go video tutorials from a former Go DevRel lead. The "implementation of X in Go" episodes are gold.

• Bill Kennedy · Ardan Labs
  Ultimate Go
  The intensive. Multi-day live or self-paced. Bill Kennedy is among the most pedagogical Go educators alive.
• Frontend Masters
  Go Fundamentals
  A polished video course covering the language; pairs well with Bodner's book.

The documentation canon.

• go.dev
  The Go Programming Language Specification
  ~80 pages. The whole language. Read it once cover-to-cover; come back when you have a "is this legal?" question.
• pkg.go.dev
  Standard library reference
  The stdlib is half the language. Browse net/http, encoding/json, io, sync, context. Each package's source is one click away.
• go.dev
  The Go Blog
  Official posts on language features, runtime improvements, and standards changes. The pace is slow and the signal-to-noise is high.
• go.dev
  The Go Memory Model
  Read once when you're tempted to share state without locks. The synchronisation rules — happens-before, channel ordering, sync.Mutex semantics — are formal here.
• go.dev
  Effective Go
  The other half of the canon. Naming, formatting, error handling, concurrency idioms.
• github.com/golang/go
  The Go Wiki
  Community-maintained. CodeReviewComments, CommonMistakes, and a long FAQ are the high-value entries.

Talks worth your evening.

• Robert Griesemer · 2017
  Prototype your design
  One of Go's three creators on language design. Why the initial Go didn't have generics; why it eventually did.
• Rob Pike · 2012
  Concurrency is not Parallelism
  The talk. Channels, gophers, mailboxes. Forty minutes. The single best framing of why Go's concurrency model is what it is.
• Russ Cox · 2018
  The Go scheduler
  Long-form on the GMP scheduler internals. Pair with the runtime/proc.go read-through.
• Brad Fitzpatrick · 2014
  Go's net package
  A tour of the net package by its primary author. A shape-of-things-to-come talk; everything in net/http still derives from these decisions.
• GopherCon · YouTube
  GopherCon recordings
  Annual conference. Talks on the runtime, the toolchain, performance, and case studies. The "performance tuning" track ages best.

Newsletters to subscribe to.

• Cooperpress · weekly
  Golang Weekly
  The standard. Curated. Pace is one issue per week. Subscribe.
• Changelog · podcast
  Go Time
  Long-form Go podcast. Topics range from runtime internals to community happenings.
• Community · GitHub
  Awesome Go
  Curated list of Go libraries by category. Start here when you need a parser, an ORM, a CLI framework — Go has fewer of these than other ecosystems on purpose.

Go toolchain cheat sheet.

Thirty commands cover ~90% of daily Go work. Memorise these; everything else is go help.

Common mistakes you'll make on day 30.

Patterns that bite every Go programmer. Read these once now; come back when you've actually been bitten.

Capturing the loop variable in a goroutine

Pre-Go 1.22: every goroutine sees the final loop value. Either copy: `i := i` inside, or upgrade to Go 1.22+ where the language fixed it. Old code is still everywhere; the race detector finds it.

nil channel send / receive

A send to a nil channel blocks forever. A receive from a nil channel blocks forever. Sometimes intentional (disabling a select case); usually a bug.

Forgetting to close a channel

You only close a channel from the sender side, and only when no further sends will happen. Closing a closed channel panics.

Goroutine leaks via context

A goroutine that does `<-ch` in a select but never gets a context.Done() case will block forever on shutdown. Always include the cancel case.

Modifying a slice while iterating

append() can reallocate. The loop sees the original backing array. Iterate the index, not the value, when mutating.

Map concurrent write panic

Plain map is not safe for concurrent write. Either guard with a sync.RWMutex or use sync.Map (only when access is mostly disjoint per key).

Defer in a long loop

Each defer adds to the function's defer stack; they only run when the function returns. Use a closure or refactor for hot paths.

Comparing time.Time with ==

Wallclock vs monotonic. Use t1.Equal(t2) — it normalises monotonic-clock readings.

Ignoring the return value of bytes.Buffer.Write

It always returns nil error, but Go community style still requires you to handle it. Use _ = w.Write(...) for clarity, or write a helper.

Returning interfaces, accepting structs

Idiom is reversed: accept interfaces, return concrete types. Returning io.Reader from your own function blurs which type the caller actually got.

Semicolony's own Go assets.

Pair these with the curriculum above. The simulators in particular let you push on the abstractions while the explanation is still fresh.

• → Go channels — buffered, unbuffered, the sender/receiver wait queues
• → Garbage collection — Go's tri-color mark-sweep, the pacer
• → Event loops — Go's netpoll vs Node's libuv
• → Memory allocation — escape analysis, the Go heap
• → Thread pools — what GMP is doing in user space

• → The GMP scheduler — work stealing, sysmon, preemption

• → JSON → Go struct converter
• → JWT encode / decode (the Go code generation reference)

The three-month roadmap.

Practice deck.

Ten cards covering the questions Go interviewers ask, the things that trip Go programmers in production, and the runtime trivia that separates "I write Go" from "I read Go".

Reading progressions

Three ordered paths through this material — pick the one that matches where you are.

Keep going.

Go rewards reading. The stdlib is well-written and short; the runtime is well-commented; the spec is small. The single best practice in Go is "read the source of the package you import", which is feasible because the source is on your disk after one go get.

Pick a real project: a CLI, a small HTTP service, a Kubernetes controller. Ship it. Then read your own code six months later and be embarrassed by what you'd write differently. That feedback loop is the best Go education there is.