A deep, reproducible course on how Go actually behaves.
Go Black Belt is about the compiler, the runtime, and the language mechanics that decide what your code costs in memory and CPU. It is not a learn-Go course, and it is not a collection of war stories. It exists to remove the mystery from Go's internals through demonstrations you can run yourself.
Evidence over folklore.
Most performance advice is folklore passed between engineers: pointers are faster, generics are zero-cost, defer is slow. Some of it is true. Some of it is true only sometimes. Most of it gets repeated without proof.
Go Black Belt holds one rule above all others: if a claim can't be demonstrated with code or tooling, it isn't in the course. Every chapter opens with a common belief, states what actually happens, and hands you a runnable lab so you can confirm it on your own machine.
- Reason about allocation, escape, and inlining before you run a benchmark, and know which benchmark to run.
- Read `-gcflags=-m`, `benchstat`, and `pprof` output without guesswork.
- Predict how a small code change shifts memory and performance, then prove it.
- Make deliberate tradeoffs between readability, abstraction, and cost.
The outcome isn't a list of rules to memorize. It's intuition grounded in evidence.
- Go developers who already write idiomatic Go and want to understand what sits underneath it.
- Curious early-career engineers building strong foundations.
- Senior and staff engineers who are tired of being surprised by allocation and performance shifts.
It assumes you're comfortable with everyday Go. It assumes nothing about compiler or runtime internals.
- People looking to learn Go syntax from scratch.
- Production incident response and distributed-systems design.
- Rule-of-thumb performance advice without proof.
Seventeen chapters, one repeatable teaching spine.
The course is grouped into five parts: allocation and escape, the compiler's optimization budget, data-structure internals, the price of abstraction, and concurrency costs. Each chapter follows the same spine:
Every chapter ships with a self-contained lab: a Go module, benchmarks, and a Makefile, so the experiment is one command away. Each lab makes precise, falsifiable micro-claims and includes a pass/fail drill so you can test your prediction against the compiler's output.
A note on numbers: absolute timings are illustrative anchors from one machine. Yours will differ. The lesson is always the relationship, the ratio, and the allocation count, never a magic nanosecond figure.
Go Black Belt is built and verified against Go 1.25, including current escape and inlining behavior, profile-guided optimization, and recent runtime changes like Swiss Table maps introduced in Go 1.24.
Go's internals move with every release, so version-sensitive behavior is labeled with the version that introduced it. When a new Go version changes something in the course, affected chapters are updated.
Go Black Belt was drafted with AI assistance and then curated, edited, and verified by a human. That second half is the part that matters: every claim in every chapter is backed by code you can run and tooling output you can reproduce against Go 1.25.
If a claim couldn't be demonstrated, it didn't make it in. You're never asked to take a sentence on faith. The proof ships with the prose, and you can run it yourself.
Built by the same person behind Go Cookbook.
Go Black Belt grew out of the same instinct behind Go Cookbook: give working Go developers something practical, tested, and honest. The project exists for people who are tired of guessing what the compiler does and would rather verify claims with runnable evidence.
Read Chapter 1 free. Run it, then decide for yourself.
It's the full chapter: escape analysis, the labs, and the exact standard the rest of the course follows.