Chapters 1 and 7 freeOne-time purchase30-day launch pricing

Learn what Go actually doesbefore you cargo-cult 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 See pricing

Total chapters

Free now

Paid unlocks

Launch pricing

Core

Full course access with the complete mechanics curriculum.

$49

$69

Complete

Best-value launch option with the exam and free Go-version course updates.

$79

$109

Team

Five seats for teams who want a shared mechanics baseline.

$299

Complete includes the practical exam and free Go-version course updates. Team includes 5 seats. No subscription.

Read before you buy

Chapter 1 covers escape analysis, the core mental model that powers the rest of the course.

Chapter 7 covers the Go 1.24+ Swiss Tables map implementation, which makes a high-signal free sample for SEO and for experienced Go readers.

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

Email-first checkout

Choose a plan, enter your email, and continue to secure checkout.

Launch pricing is live for the first 30 days: Core $49, Complete $79, Team 5-seat $299. After launch, Core rises to $69 and Complete rises to $109.

Course Map

Everything is visible. Only the launch access is selective.

Free chapters stay fully readable. Paid chapters remain browsable as previews so people can see the exact scope before buying.

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 — MeasuredPaid

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 SharingPaid

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 ItPaid

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 ProvePaid

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 RetentionPaid

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 ConversionPaid

Understand when string ↔ []byte conversions allocate, when the compiler elides the copy, and how to minimize conversion overhead.

Part IV

The Price of Abstraction

9-11

9. Interface Dispatch — Itabs, Indirection, Escape, and Typed NilPaid

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 DoesPaid

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

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

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 PreemptionPaid

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 AlternativesPaid

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 AtomicsPaid

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 NoscanPaid

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 TeaPaid

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 ActionablePaid

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

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.

What Unlocks

The paid unlock gives the rest of the mechanics stack in one go.

After Escape Analysis and Swiss Tables, the paid chapters carry the reader through memory layout, inlining, BCE, slices, interfaces, generics, concurrency costs, allocator internals, GC pacing, and cost-aware design.

Compiler behavior and optimization budget

Runtime data structures and memory retention

Allocator and GC mechanics

Concurrency primitives measured, not mythologized