Their publication
Gopheria
Go · gopheria.com
Go, beneath the surface — the runtime, concurrency, performance, and the trade-offs behind clean abstractions.
Author
Nolan Keir
Writes Gopheria — Go, beneath the surface.
Nolan Keir writes about Go, backend engineering, and the systems behind production software. His work focuses on concurrency, runtime behaviour, performance, tooling, and the trade-offs hidden behind clean abstractions. He prefers reproducible experiments and measurable behaviour over rules of thumb, and publishes the code behind every measurement.
Gopheria publishes long-form writing about Go: the language, its runtime, its frameworks, and the ecosystem that has grown around them. The tagline is the editorial policy — most of what is written about Go on the open web restates the documentation, and the site is interested in the layer underneath it. It is written for people who already read Go fluently and want to know why the scheduler made that choice, what a benchmark is actually measuring, and where the abstraction leaks.
Every claim about how something behaves or how fast it runs arrives with the means to check it: the exact Go version, the machine it was measured on, a command to run, and the actual output pasted rather than summarised. Benchmarks run with -benchmem, at least ten times, compared with benchstat, and differences are reported with their variance. When a result lands inside the noise the article says so and keeps the section — a negative result is still a result.
Nolan Keir is a publishing byline. It identifies the author of every article at gopheria.com, and nothing else — it is not the operator of the domain named in that site's legal pages.
Every issue so far
One heap shape lost 63% of its collector CPU and gained 14% throughput. Another gained 39% collector CPU and lost nothing. Same flag, same binary pair, same machine.
GOGC=100 with a 256 MiB limit produced exactly what GOGC=off produced: same collections, same CPU share, same throughput. The tighter rule binds, the other goes quiet.
A static route through net/http's mux costs 85.6 ns and nothing on the heap. A path that matches no pattern costs 2125.5 ns and 62 allocations.
One goroutine: 2.5 ns for the mutex, 172.6 ns for the channel. Sixteen goroutines with real work: the channel wins by less than the harness's own error.
Reaching a 1 MiB stack copied it nine times. The copying cost 136µs of CPU that -benchmem reports as 144 bytes, because stack memory is not heap memory.
Two sub-benchmarks calling the same function with the same argument came back 1.10% apart at p=0.000. What a benchmark measures is not only your code.
GOMAXPROCS=1 with 200 goroutines blocked in read(2) produced 202 OS threads. Measured on go1.27.0, alongside the container case Go 1.25 changed.
A pool holding 100 objects lost none across one collection and all 100 across two. Here is the victim cache, and what it costs at 122,000 ops per millisecond.
The compiler said "does not escape" and the benchmark reported 104 KiB per operation. Both were right. What -gcflags=-m actually tells you.
A blocking syscall costs an OS thread. A blocking network read costs nothing. Measured with 200 goroutines, GOMAXPROCS=2 and a thread count.
Elsewhere in the network
ElephantPHP · JS Ledger · JVM Scope · PyDepth · CSharpMind · SQLPress — six more languages, six more specialists, one imprint. Every language has a page of its own.