Learn what Go actually doesbefore you trust another performance tip.

Go Black Belt exists to teach the hardcore fundamentals of Go: how the compiler, runtime, and core language features actually behave, and what that behavior costs in terms of memory, CPU, and execution.

Read Chapter 01 free Browse the full structure

Total chapters

Free chapters

Scope

Built for evidence-backed intuition.

After completing Go Black Belt, a Go developer should: reason confidently about allocation, inlining, and escape behavior, understand how small code changes affect performance and memory, read benchmark results and compiler diagnostics without guesswork, make informed tradeoffs between readability, abstraction, and cost..

Core area

Allocation and escape

Value vs pointer semantics, interface boxing, closures, goroutines, and the compiler's proof limits.

Core area

Compiler budget

Inlining, PGO, bounds check elimination, and the small changes that silently drop optimizations.

Core area

Data and memory

Slices, Swiss Tables maps, strings, layout, alignment, allocator behavior, and GC costs.

Free Reading

Start with two chapters that stand on their own.

Read the chapter that teaches the compiler's escape decisions, then jump to the chapter that updates your map mental model for Go 1.24+ Swiss Tables. Together they show both the teaching style and the technical standard of the full course.

Chapter 01Free now

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.

compilebenchexperiment

Read this chapter

Chapter 07Free now

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.

tracebenchexperiment

Read this chapter

Course Map

See the full course before deciding if it is for you.

The free chapters are fully readable. The rest are still visible as previews, so you can understand the sequence, the goals, and the depth before requesting access.

Part I

Allocation and Escape

1-3

1. Escape Analysis — The Compiler's Fragile DecisionFree

Understand how the compiler decides between stack and heap allocation, why the decision is fragile, and how to verify it.

2. 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.

3. 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.

Part II

The Compiler's Optimization Budget

4-5

4. 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.

5. Bounds Check Elimination — What the Compiler Can Prove

Understand how the compiler eliminates array/slice bounds checks and what code patterns defeat the proof.

Part III

Data Structure Internals

6-8

6. Slices — Growth, Aliasing, and Memory Retention

Understand slice header semantics, growth behavior, aliasing hazards, and how sub-slicing retains memory.

7. Maps — Swiss Tables, Growth, and Permanent MemoryFree

Understand the Go 1.24+ Swiss Table map layout, why maps don't shrink, and how to design for memory reclamation.

8. 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.

Part IV

The Price of Abstraction

9-11

9. 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.

10. Generics — GCShape Stenciling and What Go Actually Does

Understand Go's generic compilation strategy, when generics approach monomorphic performance, and when they don't.

11. Closures and defer — Capture, Escape, and Compiler Transforms

Understand closure allocation mechanics, defer's cost model, and when open-coded defer eliminates overhead.

Part V

Concurrency Primitives Measured

12-14

12. 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.

13. 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.

14. 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.

Part VI

Memory Management Mechanics

15-16

15. 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).

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.

Part VII

Synthesis

17-17

17. Cost-Aware Design — Making Mechanics Actionable

Synthesize the mechanics from Chapters 1–16 into a repeatable framework for designing APIs and components that preserve compiler/runtime optimization opportunities.

Unlock

Why the rest is locked, and how access works.

The open chapters are there to make the teaching style legible. The locked chapters are the full course proper. If the free material feels useful, you can request launch access and I’ll follow up from there.

Read Chapter 1 and Chapter 7 in full.

Browse every locked chapter title, goal, and place in the sequence.

Choose a plan only if you want the rest unlocked.

Early access

Request access to the locked chapters.

Choose the plan that fits how deeply you want to go. Access requests are handled directly after you submit your email.

Method

The course only trusts what the toolchain can show.

Concept, experiment, observation, conclusion. The shape stays simple so the reader can build intuition from evidence rather than aphorisms.

01
Concept
Name the compiler, runtime, or memory-model mechanism precisely before discussing advice.
02
Experiment
Use the smallest reproducible lab so a single variable explains the entire outcome.
03
Observation
Read diagnostics, traces, or benchmarks instead of trusting performance folklore.
04
Conclusion
Keep only the rules that survive contact with observable toolchain evidence.