Skip to content
Cognate Press

Go at Cognate Press

Go

Go, beneath the surface — the runtime, concurrency, performance, and the trade-offs behind clean abstractions.

Published as Gopheria at gopheria.com, written by Nolan Keir — Go, beneath the surface. First issue .

Every issue on Go

  1. Green Tea cut my GC time 63%, and raised it 39%

    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.

  2. The GOGC I set next to GOMEMLIMIT never fired

    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.

  3. A 404 from net/http costs 62 allocations

    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.

  4. The mutex was 68 times faster, until I added work

    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.

  5. A 1 MiB goroutine stack costs 136µs and reports 144 B/op

    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.

  6. benchstat reported p=0.000 between a function and itself

    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.

  7. GOMAXPROCS is not your thread count

    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.

  8. sync.Pool survives one GC, not two

    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.

  9. Escape analysis is not a rule of thumb

    The compiler said "does not escape" and the benchmark reported 104 KiB per operation. Both were right. What -gcflags=-m actually tells you.

  10. What the Go scheduler does when your goroutine blocks

    A blocking syscall costs an OS thread. A blocking network read costs nothing. Measured with 200 goroutines, GOMAXPROCS=2 and a thread count.

Archive at gopheria.com ↗

The byline

Nolan Keir

Concurrency, runtime behavior and performance. Prefers reproducible experiments to rules of thumb, and publishes the code behind every measurement.

Read the profile →

What the title covers

  • Go
  • Go runtime
  • Goroutine scheduling
  • Garbage collection
  • Escape analysis
  • Benchmarking
  • Concurrency

The other languages in the imprint: PHP · JavaScript · Java · Python · C# · SQL. Each has one title and one byline behind it — the index is at Topics.