Three Go Concurrency Mistakes I See in Almost Every Worker Pool
A practical look at worker-pool mistakes around cancellation, channel ownership, and shutdown paths.
Read on MediumReading guide
Go in production: concurrency, cancellation, and the bugs that pass review.
Essays on writing Go services that hold up under load, cancel cleanly, and shut down without dropping requests. Most start from a bug that looked correct in code review. Grouped by topic, in a sensible reading order.
Concurrency and goroutines
Worker pools, bounding concurrency, and making sure goroutines actually stop.
Channel Semaphore vs x/sync/semaphore: It's Not About Speed
Benchmarking chan struct{} against x/sync/semaphore shows the performance folklore is wrong; the differences that matter are semantic.
Read on Mediumerrgroup Cancels Less Than You Think
errgroup.WithContext is a tiny API that keeps producing the same bugs. A look at its documented cancellation semantics, which are easy to assume rather than read.
Read on Mediumgoleak Has a 450 Millisecond Attention Span
Why a green goleak test suite can coexist with goroutine counts that climb all week in production, and the narrower question goleak actually answers.
Read on MediumCancellation and shutdown
Deadlines, cancellation, and deploys that don't spike 502s.
context.Context Is Not Optional: A Practical Guide to Cancellation in Go Services
A practical guide to using context.Context as part of service design, cancellation, deadlines, and shutdown behavior in Go.
Read on MediumYour Graceful Shutdown Probably Doesn't Drain
srv.Shutdown can return nil while every deploy still spikes 502s. What Go's Shutdown actually promises, and what it leaves for you to handle.
Read on MediumRunning Go in production
Finding where the time goes, and running well inside containers.
Profiling a Go Service in Production: pprof in 10 Minutes
A practical guide to enabling pprof, collecting CPU and heap profiles, reading flame graphs, and debugging Go services under real load.
Read on MediumContainer-Aware Resource Management in Go: The Problem, Go 1.25's Fix, and What's Still Missing
A practical look at Go resource management inside containers, the Go 1.25 improvements, and the gaps engineers still need to account for.
Read on MediumWriting clearer Go
Small habits that make Go code harder to misuse.
Go Interfaces: Why Less Is Almost Always More
A short note on keeping Go interfaces small, behavior-focused, and easier to test and evolve.
Read on MediumGo Slice Initialization Gotchas: The Hole-Creating Bug I Keep Seeing
A look at a common Go bug from mixing make() with a non-zero length and append, and the makezero linter that catches it.
Read on MediumWhy I Always Specify Types for Constants in Go, and Name the Unit Too
A practical note on making Go constants explicit, readable, and harder to misuse by naming both the type and the unit.
Read on Medium