Phase 0 — Setup (1–2 days)
Install Go (latest stable), set GOPATH if needed, enable modules by default.
Editor: VS Code + Go extension (or Goland). Enable linting (golangci-lint) and formatting (gofmt, goimports).
Try the toolchain: go mod init, go build, go test, go run, go doc, go vet.
Micro-tasks
Write a “hello” CLI that prints env info.
Vendor a tiny dep with go get and pin versions via go.mod.
Phase 1 — Core Language (2–3 weeks)
Goals: Comfortable with syntax, types, interfaces, and error handling.
Syntax & Types
Declarations, short :=, constants, iota.
Composite types: arrays, slices (capacity vs length), maps, structs.
Pointers (when & why; no pointer arithmetic).
Functions & Methods
Multiple return values; error as value.
Receivers (value vs pointer), interfaces, type assertions/switches.
Packages, visibility (UpperCase exported).
Control Flow
for as the only loop; if with a short statement; defer/panic/recover (use sparingly).
Generics (Go 1.18+)
Type parameters, constraints, comparable, custom constraints.
Refactor a small function to generic form; avoid over-abstraction.
Error Handling
Sentinel errors, wrapping with fmt.Errorf("%w", err), errors.Is/As.
Package-level errors vs typed errors.
Practice Project
Todo CLI: CRUD in memory; persist to JSON file; unit tests for business logic.
Checkpoints
Explain slice capacity growth.
Decide pointer vs value receiver for a type and justify.
Phase 2 — Concurrency Fundamentals (2–3 weeks)
Goals: Master goroutines, channels, and cancellation.
Goroutines & Channels
Unbuffered vs buffered channels, closing channels, range over channels.
Fan-in, fan-out, worker pools.
Context
context.Background/WithCancel/WithTimeout/WithDeadline.
Plumb context through call stacks; never store in struct.
Sync Primitives
sync.WaitGroup, sync.Mutex/RWMutex, sync.Cond, sync.Map.
When to choose channels vs mutexes.
Patterns
Pipeline with stages, backpressure with bounded channels.
Select with default; cancellation propagation.
Practice Project
Concurrent Web Crawler: crawl with worker pool, rate limiting (time.Ticker), context cancellation, graceful shutdown.
Checkpoints
Diagnose deadlocks and goroutine leaks; use go test -race.
Phase 3 — The Standard Library (2–3 weeks)
Key Packages
I/O & Files: io, os, bufio, path/filepath, embed.
Text & Data: strings, bytes, strconv, encoding/json, encoding/gob, net/url.
Networking: net, net/http, http/httptest, httptrace.
Time: time, context.
Exec & processes: os/exec, signals via os/signal, syscall.
Crypto: crypto/*, hash/*.
Practice Project
HTTP JSON Service: CRUD endpoints with net/http, middleware for logging/trace ID, request validation, structured responses, httptest coverage.
Phase 4 — Tooling, Testing & Quality (1–2 weeks)
Testing
testing basics, table-driven tests, subtests, benchmarks.
Mocks/stubs without frameworks; interfaces for seams.
Golden files for I/O heavy code.
Linting & Static Analysis
go vet, golangci-lint, staticcheck.
Modules & Build
Semantic import versions, replace directives, private modules.
Build tags, ldflags for version stamping; go generate for codegen.
Profiling & Tracing
Benchmarks: go test -bench=. -benchmem.
CPU/heap profiles: pprof; runtime tracing; GODEBUG flags.
Practice Project
Add benchmarks & pprof to previous service; find & fix a hotspot.
Phase 5 — Web Services in Production (2–3 weeks)
Routers & Frameworks
Minimalist options (chi, httprouter) vs batteries-included (gin, echo).
Architecture
Clean layering: handlers → services → repos; dependency injection via constructors (no global state).
Config via env; 12-factor compliance.
Persistence
database/sql with pgx for Postgres; context timeouts; migrations (goose, atlas).
Caching (in-memory & Redis); TTL and stampede protection.
Observability
Structured logging (zerolog/slog), metrics (Prometheus), tracing (OpenTelemetry).
Resilience
Timeouts, retries, circuit breakers, idempotency keys.
Capstone
Production-Ready Service: User service with Postgres, migrations, metrics, tracing, health/readiness endpoints, Dockerfile, docker-compose, and Makefile targets.
Phase 6 — Advanced Go (ongoing)
Generics at Scale
Generic data structures, constraints packages; performance trade-offs.
Concurrency at Scale
Batching, sharded locks, worker pools with backpressure.
Performance
Escape analysis, inlining, allocation minimization.
Memory profiling; sync.Pool; arenas (if/when stable).
FFI & Systems
cgo basics; build constraints; cross-compiling static binaries.
Security
Constant-time compares, secure randomness, secret management.
CLIs
Cobra or urfave/cli; subcommands, autocompletion, release pipelines.
Idioms & Best Practices
Return errors, don’t throw; wrap with %w.
Accept interfaces, return concrete types.
Small packages; avoid cyclic deps.
Prefer composition over inheritance.
Keep main thin; wire dependencies there.
Pass context.Context first; never store it.
Zero values should be useful.
Use time.Duration not naked ints.
Project Ladder (Portfolio-Ready)
Todo CLI (Phase 1)
Concurrent Crawler (Phase 2)
HTTP JSON Service (Phase 3)
gRPC or Connect-RPC Service
Distributed Job Queue
Observability Demo (Prometheus + OTEL)
CLI + Daemon Pair
8-Week Guided Plan (Sample)
W1–W2: Core language + Todo CLI + unit tests.
W3: Concurrency patterns + worker pool mini-labs.
W4: Stdlib HTTP service + httptest.
W5: Database integration + migrations + context timeouts.
W6: Observability + structured logs + metrics + traces.
W7: Hardening (retries, backoff, rate limits) + benchmarks & pprof.
W8: Capstone polish, Dockerization, CI, release binaries for 3 OSes.
Reading & Practice (Curated)
Official tour & docs (tour, effective go, go blog).
Source study: net/http, context, bytes, sync, runtime.
Kata: rewrite a small service channels-first vs mutex-first—compare.
