Skip to content

How to use this site

Three ways to read

  1. Path-first. Pick one of the nine paths and work it linearly: prelude → months 1–6 → appendices → capstone. Budget ~12–16 focused hours per week; the full path is a 6-month commitment.
  2. Topic-first. Use search (top right) for a concept ("garbage collection", "futex", "TLAB", "scheduler"). Hits surface across every path that covers it. Read each path's take on the same concept for a stereo view.
  3. Lab-first. Skip the prose, do the labs. Every weekly module has a "Lab" section - they are the curriculum. The prose is scaffolding.

Time budget

Cadence Hours/week Months/path Suitable for
Sprint 20+ 4 Sabbatical, between roles
Standard 12–16 6 Full-time engineer with discipline
Marathon 6–8 12 Spare-time, multi-year

Don't pretend you'll do more than you'll do. Pick a cadence you can hold, and let the time compound.

Prerequisites

The curricula assume you can already write working code in some language and have shipped production work. They are not "intro to programming." Specifically:

  • Go path: comfort with C or any systems language.
  • Java path: comfort with one OO language; pre-Java-8 experience is not required.
  • Rust path: comfort with one of {C, C++, Go, Java}; strong opinions about memory.
  • Python path: working Python; ready to read CPython source.
  • Linux path: Unix command line fluent; can read C.
  • Containers / Kubernetes: comfort with Linux + at least one application language.
  • AI Systems: linear algebra at undergrad level; one of {Python, C++}; some PyTorch.

The five-section topic template

Every weekly module is structured the same way:

  1. Conceptual Core - the why. Read first.
  2. Mechanical Detail - the how. Read with the source open in another tab.
  3. Lab - hands-on exercise. Do not skip.
  4. Idiomatic / Style Drill - read code with linters running; refactor.
  5. Production Hardening Slice - observability/perf micro-task. Compounds into a publishable template by Month 6.

If you only have time for two sections per week, do Conceptual Core and Lab. The Lab is the unit of mastery.

When to read which path

  • Backend / SRE generalist: Linux → one of {Go, Java} → Containers → Kubernetes.
  • Distributed systems engineer: one of {Go, Java, Rust} → Containers → Kubernetes → capstone with Raft.
  • AI infrastructure engineer: Python → Linux (mm + cgroups months) → AI Systems → Kubernetes (GPU scheduling).
  • Performance specialist: any language path → Linux → the production-hardening appendices end-to-end.
  • Polyglot: Go, then Java, then Rust - three takes on the same problems (concurrency, GC, FFI, RPC) is the fastest route to mastery.

When you get stuck

In order:

  1. Re-read the section. Most "I don't understand" is "I read too fast."
  2. Open the source the section references (hotspot/share/gc/g1/..., src/runtime/proc.go, kernel/sched/core.c).
  3. Run the lab with one variable changed.
  4. Search this site for the same concept on a different path - sometimes Java's lens makes Go's GC click, or vice versa.
  5. Ask a human.

System.out.println and fmt.Println are not in the top three.