The full curriculum is visible. Launch access is selective on purpose.
Read Chapter 1 on escape analysis and Chapter 7 on Swiss Tables free. The rest stay previewable but locked until purchase.
Allocation and Escape
Chapters 1 to 3.
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
Chapters 4 to 5.
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
Chapters 6 to 8.
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, when the compiler elides the copy, and how to minimize conversion overhead.
The Price of Abstraction
Chapters 9 to 11.
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
Chapters 12 to 14.
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
Chapters 15 to 16.
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
Chapters 17 to 17.
Want the rest of the course?
Enter your email, choose a plan, and continue to Lemon Squeezy checkout. Launch pricing lasts 30 days and there is no subscription.