Skip to content

Go Mastery Blueprint-A 24-Week Master-Level Syllabus

Authoring lens: Senior Staff Software Engineer / Distributed Systems Architect. Target outcome: A graduate of this curriculum should be capable of (a) submitting non-trivial PRs against golang/go (runtime, compiler, or stdlib), (b) owning a high-throughput distributed control plane (Kubernetes-class), or (c) operating a hyperscale fleet of Go services with a coherent observability story and zero-downtime deploys.

This is not "Tour of Go in 24 weeks." It assumes the reader can write working Go and has shipped production code in some language. The premise: most Go bugs at scale are not language bugs-they are runtime, scheduler, allocator, and GC bugs in disguise. This curriculum surfaces all four.

Repository Layout

File Purpose
00_PRELUDE_AND_PHILOSOPHY.md The "Go-ness" of Go; the design ethics; the cost model; reading list.
01_MONTH_RUNTIME_FOUNDATIONS.md Weeks 1–4. Toolchain, GMP scheduler, stack management, escape analysis.
02_MONTH_MEMORY_AND_GC.md Weeks 5–8. Memory layout, tricolor GC, interface itabs, GOMEMLIMIT.
03_MONTH_CONCURRENCY_MASTERY.md Weeks 9–12. Channel internals, atomics, context, leak/deadlock prevention.
04_MONTH_REFLECTION_CODEGEN_PLUGINS.md Weeks 13–16. reflect, go/ast, go generate, plugin, go-plugin.
05_MONTH_PRODUCTION_DISTRIBUTED.md Weeks 17–20. DDD, observability, gRPC, hardened testing.
06_MONTH_CAPSTONE.md Weeks 21–24. Consensus, distributed storage, perf tuning, capstone defense.
APPENDIX_A_PRODUCTION_HARDENING.md pprof, trace, golangci-lint, race detector, ldflags, build tags.
APPENDIX_B_DATA_STRUCTURES_AND_PATTERNS.md Build-from-scratch reference: lock-free queue, ring buffer, Bloom filter, LRU.
APPENDIX_C_CONTRIBUTING_TO_GO.md The Go pipeline; Gerrit; first CL playbook; runtime PR strategy.
CAPSTONE_PROJECTS.md Three terminal projects: Raft KV store, gRPC mesh, streaming pipeline.

How Each Week Is Structured

Every weekly module follows the same five-section format so the reader can budget time:

  1. Conceptual Core-the why, with a mental model.
  2. Mechanical Detail-the how, down to runtime source where relevant (src/runtime/proc.go, src/runtime/mgc.go, etc.).
  3. Lab-a hands-on exercise that cannot be completed without internalizing the concept.
  4. Idiomatic & golangci-lint Drill-read 2–3 lints, refactor a sample to silence them, understand why each lint exists.
  5. Production Hardening Slice-a pprof/trace/ - race/go vet` micro-task that compounds into a publishable hardening template.

Each week is sized for ~12–16 focused hours. Skip the labs at your peril; the labs are the curriculum.

Progression Strategy

The phases form a dependency DAG, not a linear track:

Runtime Foundations ──► Memory & GC ──► Concurrency ──► Reflection / Codegen / Plugins
        │                    │                │                       │
        └────────────────────┴────────┬───────┴───────────────────────┘
                                      ▼
                       Production & Distributed Systems
                                      │
                                      ▼
                            Capstone & Defense

The Production Hardening slice is intentionally orthogonal-it accumulates a hardening/ template that, by week 24, is a publishable Go module starter.

Non-Goals

  • This curriculum does not cover web frameworks (Gin/Echo/Fiber) as primary subjects. They appear only as integration surfaces in Month 5; net/http is sufficient for everything taught here.
  • Front-end / GopherJS / TinyGo are out of scope (pointers given in 00_PRELUDE).
  • "Why Go is better than X" advocacy is explicitly avoided. The reader should finish the program able to argue against using Go when it is the wrong tool.

Capstone Tracks (pick one in Month 6)

  1. Distributed Storage Track-a Raft-replicated key-value store with linearizable reads, snapshot/restore, multi-region demo.
  2. Service Mesh Track-a gRPC-based microservices mesh with a custom service registry, health checking, deadline propagation, and outlier ejection.
  3. Streaming Pipeline Track-a Kafka-protocol-compatible (or NATS-style) ingestion + stream-processing pipeline with at-least-once delivery and replay.

Details in CAPSTONE_PROJECTS.md.

Versioning Note

This curriculum targets Go 1.22+ as the baseline (range-over-int, range-over-func iterators stable, loopvar semantics fixed in 1.22, slog stable since 1.21, PGO stable since 1.21, GOMEMLIMIT since 1.19, async preemption since 1.14). Do not start this curriculum on a Go older than 1.22-too many of the modern idioms will be unavailable.

Print this path

Want to read offline or archive? Open the printable version — every section of this path concatenated into one page, styled for paper. Use your browser's Print → Save as PDF.