The full Go Black Belt curriculum, chapter by chapter.
Browse the complete structure across allocation, compiler behavior, data structures, abstraction costs, and concurrency.
Allocation and Escape
Escape Analysis — The Compiler's Fragile Decision
Understand how the compiler decides between stack and heap allocation, why the decision is fragile, and how to verify it.
Value Semantics vs Pointer Semantics — Measured
Determine when value returns are cheaper than pointer returns, where the crossover lies, and how receiver type affects optimization.
Memory Layout — Alignment, Padding, and False Sharing
Understand struct alignment and padding, how field ordering changes size and cache density, and how false sharing turns independent atomics into a contended hotspot.
The Compiler's Optimization Budget
Inlining — Budgets, Costs, PGO, and What Breaks It
Understand Go's inlining cost model, what causes functions to exceed the budget, how PGO changes the decision, and why inlining loss cascades into escape and allocation regressions.
Bounds Check Elimination — What the Compiler Can Prove
Understand how the compiler eliminates array/slice bounds checks and what code patterns defeat the proof.
Data Structure Internals
Slices — Growth, Aliasing, and Memory Retention
Understand slice header semantics, growth behavior, aliasing hazards, and how sub-slicing retains memory.
Maps — Swiss Tables, Growth, and Permanent Memory
Understand the Go 1.24+ Swiss Table map layout, why maps don't shrink, and how to design for memory reclamation.
Strings, Bytes, and the Cost of Conversion
Understand when string ↔ []byte conversions allocate, which proofs elide the copy on modern Go, and how to minimize conversion overhead.
The Price of Abstraction
Interface Dispatch — Itabs, Indirection, Escape, and Typed Nil
Understand the runtime cost of interface method calls — itab, indirect call, argument escape — when devirtualization removes it, and the interface-representation gotcha.
Generics — GCShape Stenciling and What Go Actually Does
Understand Go's generic compilation strategy, when generics approach monomorphic performance, and when they don't.
Closures and defer — Capture, Escape, and Compiler Transforms
Understand closure allocation mechanics, defer's cost model, and when open-coded defer eliminates overhead.
Concurrency Primitives Measured
Goroutines — Stack Growth, Scheduling Cost, and Preemption
Measure the real cost of goroutine creation, stack growth, and scheduling. Understand goroutines as a resource with allocation and GC implications.
Channels — Implementation, Contention, the Memory Model, and Alternatives
Understand the runtime implementation of channels, their contention characteristics, the memory-model guarantee they provide, and when mutexes/atomics are measurably better.
sync Primitives — Mutex Modes, Pool Eviction, and Atomics
Understand the internal behavior of sync.Mutex, sync.Pool, sync.RWMutex, and sync/atomic — and when each is appropriate.
Memory Management Mechanics
The Allocator — Size Classes, the Tiny Allocator, and Scan vs Noscan
Understand how mallocgc places objects: size-class rounding, the tiny allocator, and why pointer-free allocations are cheaper for the GC — connecting allocation (Part I) to GC cost (Chapter 16).
The Garbage Collector — Pacing, Assists, GOMEMLIMIT, and Green Tea
Understand how Go's GC paces itself, what GC assists are, why allocation rate is the primary lever, how GOGC/GOMEMLIMIT interact, and what the Green Tea experiment changes.
Synthesis
Want the rest of the course?
Choose one-time access. Launch pricing lasts 30 days and there is no subscription.
Full course access with the complete mechanics curriculum.
Best-value launch option with the exam and free Go-version course updates.
No subscription or account required. Access is tied to the email entered at Stripe Checkout and can be restored by email.