go
Go, zero to senior
A small language for big systems — types, errors, interfaces, and concurrency that actually scales.
Start track → 01
Types, errors, interfaces
Go's whole design is explicitness: values over references, errors as values, interfaces satisfied implicitly. 02
Goroutines, channels, the memory model
Goroutines are cheap because the runtime schedules them; channels and the memory model are the safety contract. 03
HTTP services with the stdlib
net/http is a production framework: routing since 1.22, middleware as wrappers, and timeouts you must set yourself — or leak connections. 01 net/http as the framework: Handler, the 1.22 ServeMux, and routing without dependencies 17 min 02 Middleware patterns: chaining, ordering, context, and the ResponseWriter wrapping traps 18 min 03 Timeouts and limits: the zero values that hold connections forever 19 min 04 Graceful shutdown: Shutdown(ctx), SIGTERM wiring, and why deploys still drop requests 18 min
04
Testing and the Go toolchain
Table tests are the idiom, fuzzing and benchmarks are built in, and the toolchain (vet, race, pprof hooks) is half the language's value. 01 Table tests and subtests: cases as data, t.Run, and why Go ships no assert library 17 min 02 Fuzzing and benchmarks: coverage-guided inputs, b.Loop, and benchstat honesty 19 min 03 Mocks, fakes, and interfaces: test doubles without testing the double 18 min 04 Modules and tooling: MVS, go.sum, workspaces, and the CI toolchain 16 min
05
Generics and package design
Generics remove copy-paste, not interfaces: constraints are type sets, instantiation is compile-time, and most code still wants an interface. 01 Type parameters and constraints: type sets, inference limits, and GCShape stenciling 18 min 02 When generics, when interfaces: the decision senior reviewers actually make 17 min 03 Package design: names as API, internal/, dependency direction, and the cycle that blocks your hotfix 19 min 04 Errors as API: sentinels, types, the Is/As contract, and the %w that leaks your internals 18 min
06
Runtime, GC, and profiling
Go's GC trades throughput for sub-millisecond pauses; escape analysis decides stack vs heap, and pprof tells you which myth you believed. 01 Memory and escape analysis: who decides stack vs heap, and what an allocation really costs 18 min 02 GC mechanics and tuning: tri-color mark-sweep, the pacer, GOGC and GOMEMLIMIT without myths 19 min 03 pprof end to end: CPU, heap, goroutine and mutex profiles from a live service to the leak 19 min 04 Benchmarking real services: percentiles, coordinated omission, and the optimization loop 18 min
07
Production patterns
Production Go is discipline: context flows down every call, config is explicit, logs are structured slog, retries respect budgets. 01 Context discipline: cancellation, deadlines, and values that flow down the call chain 18 min 02 Configuration without magic: env, flags, files, and a typed Config that fails at boot 17 min 03 Structured logging with slog: handlers, attrs, levels, and the price of every line 18 min 04 Retries and resilience: jittered backoff, retry budgets, and circuit breakers 19 min
08
Data access: database/sql and beyond
database/sql is a pool, not a connection: misSized pools starve under load, transactions pin connections, sqlc generates the boring code. 09
gRPC and API contracts
gRPC is a contract compiler: protobuf schemas version by addition only, breaking changes need new fields, gateways translate to REST. 01 gRPC and protobuf: the compiled contract, HTTP/2 transport, and the balancer that ignored your new pods 19 min 02 Contract versioning: evolve by addition, reserve dead tags, let buf breaking guard the wire 17 min 03 Gateways and REST: google.api.http annotations, transcoding limits, gRPC-Web, and the ConnectRPC alternative 17 min
10
Advanced concurrency
errgroup propagates the first error and cancels siblings; pipelines must die on context cancel or leak goroutines; backpressure beats buffers. 01 errgroup as structured concurrency: scoped goroutines, first-error cancellation, and SetLimit 18 min 02 Pipelines under cancellation: guarded sends, closing discipline, and the canonical goroutine leak 18 min 03 Semaphores and backpressure: bounding work at every boundary before the queue becomes the outage 17 min 04 Deadlock postmortems: lock-order inversion, channel-under-mutex, and reading the goroutine dump 19 min
11
Security and the supply chain
Use crypto from the stdlib and nothing clever: constant-time compares, real randomness, govulncheck in CI, minimal images by default. 01 Crypto from the stdlib, used correctly: argon2 for passwords, constant-time compares, and the GCM nonce invariant 19 min 02 govulncheck and dependency hygiene: symbol reachability, go.sum integrity, and MVS without surprise upgrades 17 min 03 Minimal container images for Go: the attack-surface ladder from ubuntu to scratch via multi-stage builds 18 min
12
Deployment and operations
A Go binary is the deploy artifact: static linking and cross-compilation, scratch containers, health probes wired to real readiness. 01 Static binaries and cross-compilation: CGO_ENABLED=0, the missing ld-linux mystery, and build-flag discipline 18 min 02 Containers for Go: GOMAXPROCS vs CPU quota, GOMEMLIMIT vs OOM, and the multi-stage Dockerfile that caches right 18 min 03 Healthchecks and lifecycle: liveness vs readiness vs startup, and the shutdown sequence that drops zero requests 18 min
13
Systems programming projects
Go is a systems glue language: CLI tools with honest exit codes, daemons under systemd, processes, files and locks done right. 01 CLI tools in Go: stdout is data, stderr is diagnostics, exit codes are the API 18 min 02 Daemons and signals: no fork dance, the SIGTERM contract, signal.NotifyContext as the one shutdown path 17 min 03 OS integration: os/exec without injection, atomic rename, advisory locks, fsnotify, and go:embed 19 min
Build with this track
Guided projects that exercise what you learn here.
Docker, containers as a system
Past 'write a Dockerfile' into how images, namespaces, BuildKit and registries actually work — and how containers behave in production.