~golangweekly | Bookmarks (149)

The Draft Go 1.25 Release Notes — We’re still about four months away from the final Go 1.25 release (expected in August) but, as always, the release notes are being worked on in advance and already provide a useful glimpse into what’s coming.

Bufstream: Kafka and gRPC for the Modern Age — A drop-in Kafka implementation with up to 8x cost savings over self-managed. See how we do it.

This 150-Line Go Program is a Full-On Load Balancer — A code-heavy walkthrough of a round-robin load balancer built solely with the standard library. It’s not production-ready, but the author offers some recommendations for moving in that direction.

Is Your Go Application's Postgres Prepared for Your Next High Traffic Event? — Do you feel like your Postgres database is a black box? Watch Postgres expert Lukas Fittl walk through the latest pganalyze features to tune slow queries, catch regressions, and keep Postgres running at its best in this on-demand video.

Optimizing Heap Allocations — When an (expected) innocuous code change had a 30% performance hit, it led to an enlightening forensic journey into stack vs heap allocation. Point yourself at this article to gain the value of understanding allocations and escape performance regressions.

A No Nonsense Guide to Go Project Layout — Say ‘no’ to overly complicated package structures, says the author, who shares a set of opinions for keeping things tight and focused with the goal of preventing ‘over complication’ in smaller projects.

Bufstream: Robust Streaming for gRPC — Meet a cloud-first, drop-in Kafka implementation custom-built for go gRPC streams. Stateless, auto-scaling, schema-aware, and up to 8x cheaper than maintaining your own Kafka stack. Read the Jepsen report.

Hunting Zombie Processes in Go and Docker — When spawning processes that in turn spawn other processes, you can run into issues where some unwanted processes stick around as zombies. This post looks at one such situation, how containers made it even messier, and how the zombies ultimately got taken out.

Preventing Accidental Struct Copies — Go lets you copy structs by value, which can cause subtle bugs—especially with locks like sync.WaitGroup or Mutex. This post digs into how a noCopy trick and go vet’s copylocks checker can catch these issues.

GoMud: A MUD (Multi-User Dungeon) Server — An in-development open source dungeon game world and library that handles the main concepts associated with MUDs, like maps, inventory and equipment, day/night cycles, etc, and allows players to connect over Telnet or HTTP.

🖼️ ImageProxy 0.12: A Caching Proxy Server and Transformer for Image Files — A long-standing project that provides a way to efficiently host image files while also allowing for basic transformations such as resizing, cropping and rotation. v0.12 is the first release in a few years and updates dependencies and adds a module for Caddy.

Go Event-Driven: Build Backend Systems That Actually Scale — Join 1000+ developers coding real projects in your IDE. No videos, just hands-on practice. Spring cohort opens soon.

🤖 MCP Go: A Go Implementation of the Model Context Protocol — The Model Context Protocol (MCP) is a rapidly growing way to provide a way for LLMs and AI agent based devtools with access to external services. Why let Pythonistas have all the fun when you could be developing your own MCP servers with Go?

Doltgres Beta Launch: A Version Controlled SQL Database — As well as dropping lots of great Go articles on their blog, the folks at DoltHub also develop database software ;-) Doltgres is a Postgres-flavored variant of their SQL database that offers Git-style merging and forking, and it’s all built in Go.

Cheating the Reaper in Go — How far can you push manual memory management in Go despite its garbage collector? Miguel peels back Go’s GC internals to craft a blazing-fast arena allocator in pure Go—with nothing more than unsafe wizardry—and shows exactly when (and how) you can safely outmaneuver the GC’s reaper.

Fuzzing Go Binaries with LibAFL — Built upon the Rust-powered LibAFL fuzzing library, GoLibAFL brings ‘state-of-the-art fuzzing techniques’ to Go developers. This post compares it to existing solutions, shows off some examples, and digs into how they tailored LibAFL for Go use cases.

Mockery v3: Create Mock Implementations of Interfaces — With the very bold claim of Mockery v3 being able to make “obsolete all other interface-based code generation frameworks” in the Go world, the author has a good go at explaining why. If you’d rather just see the facts and give it a go, the homepage is a good place to start.

Bufstream: Robust Streaming for gRPC — Meet a cloud-first Kafka implementation custom-built for go gRPC streams. Plus, Bufstream is Jepsen‑tested.

Vite Backend Integration for Go — A way to integrate a Vite-based frontend with a Go-based backend app.

Complete Go for Professional Developers — Craft production-grade APIs with Go, the language trusted by tech giants! Connect to Postgres, implement auth, and write tests that matter. Taught by a Twitch ML engineer who solves real problems with Go daily.

Using Signals with Go — Signals are asynchronous messages sent to processes to notify them of events like interrupts, crashes or termination, or to trigger certain behaviors. Most languages let you catch signals and act upon them, such as for shutting down a program gracefully, and Go is no exception.

sync.Pool is Not a Silver Bullet — sync.Pool can reduce allocations and GC pressure, but it’s not a drop-in solution for every case. Jens looks at where pooling shines (predictable, short-lived objects) and when it can backfire.

Hoard of the Rings: Extracting Data From a Cheap Activity Tracker — Tony picked up a cheap activity tracking (heartrate, steps, etc.) ring and figured out how to use TinyGo to read its outputs. A fun yet practical use for TinyGo!

Faster Shuffling in Go with Batching — Put down that deck of cards.. ‘shuffling’ here refers to moving the contents of an array about. It is based on expensive random integer generation. Here, Daniel offers up a couple of algorithms that speed things up by 2-3X compared to Go’s standard Fisher-Yates shuffle.