Go Engineering

Learn Go the way a systems engineer needs it: what every value looks like in memory, what the allocator, garbage collector and scheduler do on your behalf, how to measure and speed up a program — and how to build neural networks, tokenizers, LLM clients and model servers in it.

Every other path in this library writes its code in Go. This is the path about Go itself. It starts at “what is a variable” and ends with a transformer forward pass and a batching model server, both written from nothing but the standard library.

It assumes you have programmed in some language. It does not assume you know Go, C, or how a garbage collector works.

How this course works#

Every lesson follows the same shape:

1. The idea in one minute — the whole lesson in a few sentences.
2. An analogy — something from everyday life with the same shape.
3. A picture — a hand-drawn diagram, usually of memory.
4. How it really works — the precise version, with real sizes and names.
5. Code — a small Go program you can run. Nearly all of them measure the thing the lesson claims, so you never have to take the text’s word for it.
6. Remember this — the three or four facts worth keeping.
7. Try it and Check yourself — exercises and questions.

Why draw memory?#

Most Go surprises are memory surprises: a slice that changes behind your back, an interface that is “nil but not nil”, a goroutine that leaks, a program that spends a third of its time in the garbage collector. Each one stops being a surprise once you can draw the bytes.

flowchart TB
  SRC["Your code<br/>values, pointers, goroutines"] --> CMP["Compiler<br/>escape analysis, inlining"]
  CMP --> BIN["One static binary<br/>your code + the runtime"]
  subgraph RT["The Go runtime, inside your process"]
    SCH["Scheduler<br/>goroutines onto threads"]
    ALC["Allocator<br/>size classes, spans"]
    GC["Garbage collector<br/>concurrent mark and sweep"]
  end
  BIN --> RT
  RT --> OS["Operating system<br/>threads, memory pages, sockets"]
  class SRC neutral
  class CMP,BIN compute
  class SCH queue
  class ALC,GC memory
  class OS io

The path#

flowchart LR
  I["I The language"] --> II["II Data in memory"]
  II --> III["III Memory"]
  III --> IV["IV Concurrency"]
  IV --> V["V Performance"]
  V --> VI["VI AI in Go"]
  class I neutral
  class II,III memory
  class IV queue
  class V compute
  class VI io

What you need#

• Go 1.22 or newer. Every runnable program in the course builds with it. Lessons mark the few features that need a newer release and show them as snippets.
• A terminal. No other tools, no GPU, no Python.

Getting started in fifteen minutes#

1. Install Go from go.dev/dl and run go version.
2. Read I.01 and run its program with go run.
3. If you already write Go, start at II.01 — module II is where the pictures begin — or go straight to III.02 Escape analysis.
4. If you came for the AI part, read VI.01 first; it says which earlier lessons each AI lesson leans on.

A note on versions#

Go releases every six months and keeps a strict compatibility promise: code written for Go 1.0 still compiles. The language changes slowly; the runtime improves constantly. On 3 October 2026, when this course was last checked, the current release was Go 1.27 (August 2026). What recent releases changed, in the order the course meets them:

Runtime internals — sizes, thresholds, algorithms — are implementation details and do change. Wherever the course quotes one, the program beside it measures it on your machine.

Sister paths#

• Inference Engineering — the serving systems most of module VI points toward.
• GPU Engineering — the hardware underneath.
• Observability Engineering — measuring what you build here once it is running.