Go: Connection Reuse Revolution and Performance Wins

Transcript

Hey there, gophers! Welcome back to another episode of Go. I'm your host, and wow, do we have some exciting stuff to talk about today - February 3rd, 2026. You know that feeling when you discover a performance optimization that just makes everything better? Well, we've got several of those today!

So here's what happened - we had 12 fantastic commits land, and honestly, there are some real gems in here that are going to make your Go code faster and more efficient without you having to change a single line.

Let me start with the absolute star of today's show. Nicholas Husin just landed a game-changing improvement to HTTP client connection reuse. You know how frustrating it's been that Go's HTTP client couldn't reuse connections when you didn't read the entire response body? Well, that inconsistency is now history!

Here's the beautiful part - when you close a response body now, Go will automatically try to drain up to 256 kilobytes of remaining content, but only for up to 50 milliseconds. It's like having a smart assistant that cleans up after you, but knows when to stop if the mess is too big. This brings HTTP/1 client behavior in line with what the server side already does, and honestly, this is one of those changes that's just going to make everyone's apps more efficient.

Then we've got Joe Tsai working some serious magic on JSON encoding performance. You know that pattern we've all used - `json.NewEncoder(out).Encode(in)` - where you create a single-use encoder? Well, Joe noticed this was performing poorly in the v2 implementation because it wasn't using the global encoder pool anymore. The fix? Make it use the internal pooled encoder from v2. The results are incredible - we're talking about 20% faster encoding, 46% less memory allocation, and 50% fewer allocations. That's the kind of optimization that makes me genuinely excited about performance work.

Meanwhile, Arseny Samoylov has been doing some really thoughtful compiler work, streamlining map access functions by replacing mapaccess1 calls with mapaccess2. It's one of those internal changes that shows the attention to detail the Go team brings - simplifying the codebase while maintaining full compatibility.

And speaking of attention to detail, Ian Lance Taylor has been on a cleanup mission, fixing some test issues where temporary directories weren't being properly deleted. It might seem small, but these kinds of housekeeping improvements make the development experience so much better for everyone.

I also want to highlight Brad Fitzpatrick's network resolver fix. If you've ever had a Go process start up before your DHCP client finished writing `/etc/resolv.conf`, you used to be stuck waiting up to 5 seconds. Not anymore! This is exactly the kind of real-world problem solving that makes Go such a pleasure to work with in production environments.

Today's Focus section - and this is practical stuff you can use right now. First, if you're doing a lot of HTTP client work, you can now be a bit more relaxed about reading entire response bodies. The automatic draining will help with connection reuse. But remember, it's still good practice to read what you need.

Second, if you're using that `json.NewEncoder` pattern I mentioned, know that it's now more efficient than ever, but consider whether you might benefit from reusing encoders in hot paths.

And here's the bigger picture - these commits show Go continuing to evolve in really thoughtful ways. Performance improvements that happen automatically, better resource management, and fixes for real-world deployment scenarios. This is why I love working with Go - the team is constantly making the language better while keeping it simple and reliable.

That's a wrap for today! Keep coding, keep learning, and remember - every small optimization matters. Catch you tomorrow with more Go goodness!