<p><strong>TLDR:</strong> Bluesky published a detailed post-mortem on an 8-hour outage caused by unbounded goroutine concurrency exhausting TCP ports and cascading into OOMs. Separately, a security researcher found two compiler bugs in Go up to 1.26.1 that break memory safety guarantees using only safe code. On the tooling side, Google’s Agent Development Kit for Go hit v1.0, and constmap landed with 3x faster lookups than the built-in map.</p>
<hr>
<h2>Bluesky’s April outage: missing <code>errgroup.SetLimit</code> took down 50% of users for 8 hours</h2>
<p>A single missing concurrency limit in a <code>GetPostRecord</code> RPC handler let batches of 15-20k URIs spawn tens of thousands of goroutines simultaneously. That exhausted ephemeral TCP ports via memcached connection churn, which triggered millions of log writes per second, which caused the Go runtime to spawn roughly 10x more OS threads, which stressed the GC into long stop-the-world pauses, which combined with aggressive <code>GOGC</code>/<code>GOMEMLIMIT</code> settings to cause OOMs. On restart, TIME_WAIT sockets blocked new memcached connections and the whole cycle repeated. The band-aid was a custom dialer that randomized the loopback source IP across the full <code>127.0.0.0/8</code> range to expand the available port space. The real fix was one line: <code>errgroup.SetLimit</code>. The lessons are worth reading — bound goroutine concurrency in every batch endpoint, prefer Prometheus/OTEL over high-volume logging, and add per-client observability before you need it.</p>
<h2>Two Go compiler bugs break memory safety without <code>unsafe</code></h2>
<p>A security researcher found and reported two bugs in Go up to 1.26.1 that produce memory corruption using only safe Go code. The first is in the <code>prove</code>/<code>loopbce</code> optimization pass, which incorrectly reasons about signed integer wrap in induction variables and eliminates bounds checks when the index can actually go negative. The second is in SSA lowering, where a no-op type conversion causes the compiler to skip the safe overlapping-copy path. Both share the same root cause: the compiler promoting “probably safe” to “proved safe” prematurely. The researcher calls this “counterfeit certainty” — and in a twist, git blame showed they had introduced the underlying code for the first bug themselves three years earlier. The takeaway is blunt: memory safety is a property of the whole toolchain, not just the language spec.</p>
<h2>constmap: immutable string maps with 3x faster lookups and 6x less memory</h2>
<p>constmap is a new Go library for immutable string-to-uint64 maps using the binary fuse filter algorithm. Lookups cost one hash computation, three array accesses, and two XOR operations — benchmarks show 7.6 ns/op versus 23 ns/op for the built-in map, and 9 bytes per key versus 56. There’s a <code>VerifiedConstMap</code> variant that detects missing keys at the cost of doubled memory. It supports serialization with FNV-1a checksum validation. The obvious constraint is that the map is immutable after construction, so it fits a specific set of use cases — config lookups, routing tables, static datasets — but for those it’s a meaningful improvement.</p>
<h2>Google’s ADK for Go hits v1.0</h2>
<p>Google’s Agent Development Kit for Go reached v1.0 this week, shipping with OpenTelemetry integration, self-healing logic, and safety guardrails. A demo walkthrough showed a sailing trip planner built with it: parallel agents combining deterministic API calls (weather, tides, sunrise math) with AI sub-agents for localized content. One architectural note worth flagging — the Google Search tool had to be isolated into a sub-agent due to a known ADK/Gemini incompatibility. A Temporal integration for durability and automatic retries is apparently coming.</p>
<hr>
<h2>Also notable</h2>
<ul>
<li><strong>Solod transpiler:</strong> Converts a strict subset of Go to readable C11 with zero runtime, no GC, and no CGO — goroutines, closures, and generics are excluded, but structs, interfaces, slices, and defer are supported.</li>
<li><strong>Bloom filters in production:</strong> A case study on using Go Bloom filters in a recommender service at 18k req/s showed p95 latency drop from ~140ms to ~96ms and backend read traffic down ~65-70%.</li>
<li><strong>Let’s Encrypt’s certificate test infrastructure:</strong> Built in Go using the Lego ACME library, it maintains valid, expired, and revoked certificates simultaneously — keeping a revoked cert non-expired is the hard part — with SNI-based selection via <code>GetCertificate</code>.</li>
<li><strong>Go compiler keyword count:</strong> Go has 25 reserved keywords, fewer than Python (35), C (43), Rust (48+), or Java (68). Useful framing for onboarding conversations.</li>
<li><strong>TinyGo now supports 100+ boards:</strong> Including ESP32s and the Game Boy Advance; GC is implemented but slow and unsupported on AVR and WASM targets; no wireless support yet.</li>
<li><strong>vif PHP package manager:</strong> Written in Go, uses PubGrub dependency resolution (same as Python’s uv), benchmarks at ~8.4s vs Composer’s ~18s on cached runs; pre-alpha but produces compatible <code>composer.lock</code> files.</li>
<li><strong>watgo WASM toolkit:</strong> Zero-dependency Go library and CLI for parsing, validating, encoding, and decoding WebAssembly modules; passes the full official spec test suite.</li>
<li><strong>pgit Linux kernel import:</strong> Stored 1.4M commits and 24.4M file versions in a 6.6 GB Postgres database in 2 hours; full-history SQL queries run in seconds.</li>
<li><strong>Sky language:</strong> Experimental Elm-inspired language that compiles to Go, with Hindley-Milner types, exhaustive pattern matching, and a Phoenix LiveView-style server-driven UI framework; compiler is self-hosted.</li>
<li><strong>PlanetScale Postgres traffic control patterns:</strong> Practical Go patterns for per-service isolation, route-level tagging via HTTP middleware, and graceful degradation on blocked queries using <code>SQLSTATE 53000</code>.</li>
</ul>


Go language updates, concurrency patterns, and community projects.

Go Digest

A Go-focused roundup covering four major stories: Bluesky's post-mortem on an 8-hour outage caused by unbounded goroutine concurrency exhausting TCP ports and cascading into OOMs (fixed with a single errgroup.SetLimit call); two Go compiler bugs up to v1.26.1 that break memory safety guarantees using only safe code via flawed optimization passes; the constmap library offering 3x faster and 6x more memory-efficient immutable string map lookups using binary fuse filters; and Google's Agent Development Kit for Go reaching v1.0 with OpenTelemetry and self-healing support. Also covered: the Solod Go-to-C11 transpiler, Bloom filters in production at 18k req/s, TinyGo supporting 100+ boards, and several other Go ecosystem projects.

Bluesky's goroutine death spiral, two Go compiler memory safety bugs