64 courses, two planes.

Go from the first line

Types, slices, maps, structs, errors and modules, written from nothing on your own machine until you have a command-line tool you would actually use. For people who have never written Go, whatever else they've written.

[]string{"Slices", "Errors", "Modules", "go test"}

Go that reads like Go

Small interfaces, composition, error wrapping, generics and iterators: the habits that separate Go from other languages written in Go. You refactor a working package until it's half the length and easier to test.

[]string{"Interfaces", "Generics", "Iterators", "errors.Is"}

The Go toolchain, properly

Table tests, fuzzing, benchmarks, pprof, the race detector, vet and build tags: the tools that ship with the language and go mostly unused. You find a real allocation hot spot and prove the fix with numbers.

[]string{"Fuzzing", "Benchmarks", "pprof", "Build tags"}

Deep dive

The Go runtime from the inside

The scheduler, growable stacks, escape analysis, the garbage collector and write barriers, read from the runtime's own source. You trace a goroutine from the go statement to a thread and back, and predict what the collector will do before it does it.

[]string{"Scheduler", "Escape analysis", "GC", "Write barriers"}

Goroutines and channels

What a goroutine is, how channels synchronise, and how to stop a program that has started many things at once. You build a small concurrent crawler and shut it down cleanly. For people who have only written code that does one thing at a time.

[]string{"Goroutines", "Channels", "select", "WaitGroup"}

Concurrency patterns that hold up

Context, errgroup, worker pools, pipelines, cancellation and backpressure. You take a service that leaks goroutines under load and make it shut down cleanly every time.

[]string{"context", "errgroup", "Worker pools", "Backpressure"}

Races, locks and atomics

The Go memory model, mutexes, atomics, and what the race detector can and can't see. You find real races in a real codebase and fix them without putting one lock around everything.

[]string{"Memory model", "sync.Mutex", "Atomics", "-race"}

Deep dive

Go under load

GOMAXPROCS, contention profiles, sync.Pool, GOGC and GOMEMLIMIT, and how the scheduler behaves at the edge. You push a service until latency falls apart, find out why, and move the edge.

[]string{"GOGC", "GOMEMLIMIT", "Contention", "Tracing"}

Testing Go from the first test

Table tests, subtests, helpers, httptest and what makes a test worth keeping, on code you wrote without any. For people whose test suite is mostly hope.

[]string{"Table tests", "Subtests", "httptest", "Coverage"}

Testing against the real thing in Go

Real PostgreSQL and Redis in containers, fakes instead of mocks, golden files, and testing/synctest for code that depends on time. You delete the tests that were only testing the mocks.

[]string{"Testcontainers", "Fakes", "Golden files", "synctest"}

Property tests and fuzzing in Go

Native fuzzing, property-based tests with rapid, and mutation testing, to catch the cases nobody thought to write down. You let the computer break your parser, then fix what it found.

[]string{"Fuzzing", "Property tests", "rapid", "Mutation testing"}

Deep dive

Load, failure and legacy Go

Load tests with k6, fault injection, and upgrading an old codebase in small safe steps. You push a real service until it falls over, find out what breaks first, and change it without a rewrite.

[]string{"Load testing", "Fault injection", "Upgrades", "Legacy code"}

Your first Go service

An HTTP API with net/http and nothing else: routing, JSON, middleware, validation, errors a client can act on, and tests that call real handlers. For people who have used web frameworks and want to see what's under them.

[]string{"net/http", "ServeMux", "Middleware", "httptest"}

Go and PostgreSQL

database/sql, pgx and sqlc, connection pools, transactions, migrations and the bugs that only show up under concurrent writes. You take an endpoint from a slow, racy query to a fast, correct one.

[]string{"pgx", "sqlc", "Transactions", "Migrations"}

gRPC and service contracts in Go

Protobuf, gRPC, streaming, deadlines, retries and schema changes that don't break a client you can't see. You split one service in two and evolve the contract between them without downtime.

[]string{"Protobuf", "gRPC", "Deadlines", "Versioning"}

Deep dive

A storage engine in Go

A write-ahead log, a B-tree, fsync and crash recovery, built from an empty file. You pull the plug in the middle of a write, restart, and prove that nothing was lost.

[]string{"WAL", "B-trees", "fsync", "Crash testing"}

SQL for Go developers

Tables, keys, joins, aggregates, transactions and schema design, written by hand in psql and then called from Go. For people who have let an ORM do all of this so far.

[]string{"Joins", "Transactions", "Schema design", "psql"}

Caching and Redis in Go

Cache-aside, expiry, invalidation, stampedes stopped with singleflight, and the data structures that make Redis more than a map. You take a read-heavy endpoint down by an order of magnitude and keep it correct.

[]string{"Invalidation", "singleflight", "Expiry", "Sorted sets"}

Streams with Kafka and NATS in Go

Consumer groups, ordering, the transactional outbox and why exactly-once is harder than it sounds. You split one feature out of a monolith without losing a single event.

[]string{"Kafka", "NATS", "Outbox", "Consumer groups"}

Deep dive

A query engine in Go

A SQL parser, a planner and an executor with indexes and joins, built over your own storage. You run one query through every stage and can say exactly why the plan came out the way it did.

[]string{"Parsing", "Query planning", "Joins", "Indexes"}

Networks from a raw socket in Go

TCP, DNS, timeouts and connection pools, with the net package on one side of the screen and a packet capture on the other. For people who have only ever seen a network through an HTTP client.

[]string{"TCP", "DNS", "Timeouts", "Packet capture"}

Build a reverse proxy in Go

Load balancing, health checks, retries, TLS termination and HTTP/2, in a proxy you write yourself. You put it in front of a real service and kill backends while the traffic keeps flowing.

[]string{"Load balancing", "Health checks", "Retries", "HTTP/2"}

Replication and consistency in Go

Leaders, followers, quorums, clocks and what the word consistency actually promises, on a replicated store you can partition on purpose. You watch each guarantee hold, then watch it fail.

[]string{"Replication", "Quorums", "Clocks", "Partitions"}

Deep dive

Write your own Raft in Go

Leader election, log replication and snapshots, from the paper to a working key-value store, tested on a simulated network that drops, delays and reorders everything. You find out why the paper is so careful.

[]string{"Raft", "Consensus", "Snapshots", "Simulation"}

Secure Go from day one

Input validation, SQL injection, secrets, password hashing and safe defaults, built into a small service from the first commit. For people who have only thought about security after something went wrong.

[]string{"Validation", "Injection", "Secrets", "Password hashing"}

Authentication and authorisation in Go

Sessions, OAuth 2, OpenID Connect, where JWTs help and where they hurt, and permissions that stay readable as the rules grow. You secure one API for a browser and a mobile app at once.

[]string{"OAuth 2", "OIDC", "JWT", "Permissions"}

TLS and cryptography in Go

The standard library's crypto packages, certificates, mutual TLS between services, and which primitives to reach for and which to leave alone. You run your own small certificate authority and rotate its keys without downtime.

[]string{"TLS", "mTLS", "Certificates", "Key rotation"}

Deep dive

Breaking Go services

Your own code, read the way an attacker reads it: SSRF, races as vulnerabilities, unsafe parsing and the supply chain, with govulncheck on the way. You break into a deliberately weak service, then close every hole you used.

[]string{"SSRF", "govulncheck", "Threat modelling", "Supply chain"}

Ship a Go binary

Static builds, cross-compiling, small container images, systemd and a CI pipeline, ending with your service on a real server. For people whose code has only ever run on their own machine.

[]string{"Static builds", "Containers", "systemd", "CI"}

Observability in Go

Structured logs with slog, metrics and traces with OpenTelemetry, continuous profiling and alerts that mean something. You instrument a service until you can explain any slow request from the trace alone.

[]string{"slog", "OpenTelemetry", "Metrics", "Alerts"}

Go on Kubernetes

Probes, graceful shutdown, resource limits and what GOMEMLIMIT should be set to, then client-go and a small controller of your own. You run a rolling deploy under load and nobody sees an error.

[]string{"Probes", "Graceful shutdown", "client-go", "Controllers"}

Deep dive

Go at high traffic

Load shedding, connection pools, memory leaks, profiling in production, capacity planning and running an incident. You keep a service up through a simulated launch day, then write the postmortem.

[]string{"Load shedding", "Capacity", "Leaks", "Incidents"}