Go syllabus

Updated

July 30, 2026

Syllabus — expert path for Go

Status: Canonical outline for Sub-book 1.
Baseline: Go 1.26.x.
Voice: Journey / practice notebook. Ordering: expert pedagogy.

Important

Chapters follow this path. Research day-tables (Session 2, Zai) are inventories—not calendars of record.

Why this order (expert rationale)

Principle What we do What we avoid
Sequential before concurrent Solid types, slices, interfaces, errors first Goroutines in week 1
Ship small early CLI / library mini-projects each stage Pure theory weeks
Tests as culture Table-driven tests from Stage II onward “We’ll test in phase 7”
Stdlib first net/http, database/sql, slog before frameworks Framework tourism
Generics after pain Introduce when duplication is real Generics day 2
Measure before mysticism pprof after a real service exists Premature SIMD / micro-opts
Cloud-native is elective depth k8s client/operator as optional track Forcing every learner through operators
One capstone Integrate under one design Ten disconnected demos

Sources used as inventory

  • 90 Days of X Session 2 Go tables (day prompts, Go 1.26 notes, mini-projects)
  • 90 Days of X Zai Go book (depth lists, weekly reviews)

Stage map

Stage Days Theme Gate
I 1–10 Toolchain + core sequential Go Small typed CLI; explain slices/maps
II 11–18 Methods, interfaces, errors, modules Idiomatic module + tests
III 19–30 Concurrency, context, correctness Race-clean pipeline with cancellation
IV 31–38 Generics + testing depth Generic helper + solid test suite
V 39–50 Stdlib I/O, HTTP, encoding, slog Tested HTTP service
VI 51–62 Data, APIs, service boundaries Service + DB (or repository interface)
VII 63–74 Tooling, perf, containers, observability Profiled, containerized binary
VIII 75–90 Architecture, production, capstone Capstone demo + retrospective
Elective TinyGo 1–5 Embedded Go / soft realtime (optional) Blink/IRQ/UART/tasks/I2C labs green

Days ≈ 3h blocks. Gates beat calendars. TinyGo elective does not replace Days 1–90.

TinyGo elective map

# Chapter Focus
T1 92-tinygo-01-toolchain-blink Install, targets, blink / wasip1
T2 93-tinygo-02-button-irq Debounce, poll vs IRQ
T3 94-tinygo-03-uart-sensor Fixed-rate loop, misses, EMA
T4 95-tinygo-04-coop-tasks Cooperative multi-rate tasks
T5 96-tinygo-05-i2c-monitor I2C or mock + health status

Cross-ref: monorepo Go/content/99-projects/100o–100s.

Stage I — Toolchain & sequential core (Days 1–10)

Day Focus Hands-on
1 Install Go 1.26; modules-era mental model; go env Hello world; inspect build
2 Vars, types, constants, conversions Small units CLI
3 Control flow (if/switch/for) Non-toy control exercise
4 Functions, multiple returns, defer basics Helpers with errors as values (preview)
5 Arrays vs slices; slice header; append Ring buffer or growable buffer
6 Maps; comma-ok; iteration Word count / simple cache
7 Structs; embedding; value vs pointer receivers Domain model (inventory, etc.)
8 Pointers; escape analysis intro Explain -gcflags=-m on Day 7 code
9 Packages & visibility; project layout intro Multi-package toy module
10 Gate Stdlib-only mini CLI using structs + slices + maps

Zai depth to weave: zero values, untyped constants, labeled loops only if needed.

Stage II — Interfaces, errors, modules (Days 11–18)

Day Focus Hands-on
11 Interfaces; implicit satisfaction; any Refactor domain behind interfaces
12 Type assertions / type switches; nil interface gotcha Safe assertion helpers
13 Errors: wrapping, Is/As/Join Validation library with inspectable errors
14 Panic/recover — rare and deliberate Safe-call wrapper; know when not to
15 Modules: go.mod/go.sum, semantic import paths Tidy module; explain versions
16 Table-driven tests; t.Run; helpers Tests for validation + domain
17 Fakes vs mocks; interface-driven tests Mock a dependency by hand
18 Gate Publishable-shaped module: API + tests + README

Stage III — Concurrency (Days 19–30)

Day Focus Hands-on
19 Goroutines; scheduler mental model (G/M/P light) 10k goroutines without meltdown
20 Channels; close; nil channel Producer/consumer
21 select; timeouts Multiplex fan-in
22 sync primitives; channels vs mutex Three thread-safe counters + benchmark
23 Worker pools; pipelines Bounded concurrent fetcher
24 context: cancel, deadline; values sparingly Cancel the fetcher cleanly
25 Race detector; leaks; deadlocks Break then fix a racy program
26 Concurrency patterns catalog Fan-out with error propagation
27 errgroup (or equivalent discipline) Parallel work with first-error cancel
28 Memory model lite; happens-before intuition Document one race you fixed
29 Integration day Combine pipeline + context + tests
30 Gate Race-clean concurrent tool with graceful shutdown

Stage IV — Generics & testing depth (Days 31–38)

Day Focus Hands-on
31 Type parameters; constraints Generic Map/Filter
32 Generic data structures; self-referential constraints (1.26 notes) Small generic collection
33 When not to use generics Refactor that removes needless generics
34 Fuzzing Fuzz a parser
35 Golden files; t.Cleanup Snapshot tests for encoding
36 Concurrent tests / synctest awareness Test a pipeline under concurrency
37 Go 1.26 quality pass go fix; note Green Tea GC / new(expr) where relevant
38 Gate Generic helper + fuzz or deep tests on a real package

Stage V — Stdlib that pays rent (Days 39–50)

Day Focus Hands-on
39 io interfaces; composition Transforming Reader
40 bufio / bytes / strings Streaming parser
41 encoding/json (+ awareness of json/v2 direction) Config loader with custom types
42 os / os/exec Subprocess with timeout
43 time; timers/tickers Simple scheduler
44 net basics TCP echo
45 net/http server; middleware chain Small HTTP API
46 net/http client; transports Client with timeouts
47 log/slog Structured logs end-to-end
48 Templates / regexp as needed One real text task
49 httptest + full handler tests Cover Day 45 API
50 Gate HTTP service: slog + tests + clean shutdown

Stage VI — Data & APIs (Days 51–62)

Day Focus Hands-on
51 database/sql + pooling Repository over Postgres (or SQLite if constrained)
52 Migrations; sqlc vs ORM trade-off Prefer sqlc-style or explicit SQL
53 REST design with stdlib mux Versioned JSON API
54 Authn/z basics (JWT or session) Protect routes
55 Validation & problem details Consistent error JSON
56 gRPC optional track A Protobuf + unary RPC or skip to deepen REST
57 gRPC optional track B Streaming/interceptors or REST gateway polish
58 Caching pattern (Redis optional) Cache interface + one impl
59 WebSockets or SSE (pick one) Live updates endpoint
60 TLS awareness for services Local HTTPS or documented terminate-at-proxy
61 Integration tests testcontainers or dockerized deps if available
62 Gate Service + data store + auth + tests

Stage VII — Ship quality (Days 63–74)

Day Focus Hands-on
63 Build tags; cross-compile linux/arm64 + darwin/arm64 artifacts
64 Vet/staticcheck; module private/replace Lint-clean module
65 pprof CPU/heap Profile a hot path
66 Benchmarks; allocs Optimize with evidence
67 GC tuning awareness (GOGC/GOMEMLIMIT) Measure one workload
68 Containers; distroless/scratch Containerize the service
69 Metrics (Prometheus client) One useful exporter metric
70 OpenTelemetry traces (light) Trace one request path
71 CLI ergonomics (cobra optional) Multi-command tool or flags-only polish
72 Supply chain: govulncheck Remediate findings
73 Elective: k8s client-go or deepen service Choose deliberately
74 Gate Profiled, scanned, containerized release candidate

Stage VIII — Architecture & capstone (Days 75–90)

Day Focus Hands-on
75 Package boundaries; accept interfaces return structs Boundary refactor
76 Hexagonal / clean architecture lite Ports for Day 62 service
77 Config layering (flags/env/file) 12-factor-ish loader
78 Graceful shutdown; health probes Production lifecycle
79 Feature flags / progressive delivery awareness One flag gate
80 Load test (k6/vegeta) Find a bottleneck
81 Security checklist pass Fix top issues
82 Design doc for capstone Written plan
83–88 Capstone build One integrated system (see below)
89 Harden: tests, govulncheck, profile, load test Evidence pack
90 Demo checklist + retrospective + Go 1.27 roadmap Close the volume

Capstone options (pick one)

A — Control/observability agent (Session 2 flavored): watch processes/containers, metrics, small control API, slog, containerized.

B — Domain microservice: REST (and optional gRPC), DB, auth, tests, metrics.

C — Serious CLI product: multi-command tool with tests, release artifacts, optional Nix packaging join.

Avoid building A+B+C in one capstone.

Explicitly out of scope (spine)

  • Full cloud certification content
  • Every ORM/framework comparison
  • Mandatory Kubernetes operator career path
  • Deep unsafe production use
  • Replacing the official Go tour/blog/specs

Resources

  • The Go Programming Language (Donovan & Kernighan) — fundamentals
  • Learning Go (Bodner) — modern idioms
  • 100 Go Mistakes (Harsanyi) — phase-end gap checks
  • Official release notes for 1.24–1.26 — primary source

Writing rule

  1. Follow Stages I→VIII.
  2. Each chapter: idea → code → test → gotcha.
  3. Prefer stdlib until a library clearly pays rent.
  4. Update this syllabus before expanding scope.