languages

Patterns and Techniques for Writing High-Performance Applications with Go

Most caching libraries get TTL expiration wrong. They focus on per-key complexity while missing the patterns that actually prevent production outages.

When it comes to test organization, Go’s standard testing library only gives you a few options. I think that’s a great thing because there are fewer details to remember and fewer things to onboard people to. However, during code reviews, I often see people contravene a few common conventions around test organization, especially those who are new to the language. If we distill the most common questions that come up when organizing tests, they are:

84 million requests a second means even rare bugs appear often. We'll reveal how we discovered a race condition in the Go arm64 compiler and got it fixed.

Every Go developer eventually hits the same wall: your code works, but it's not fast enough. You've optimized your algorithms, removed unnecessary loops, and still—something's off. More often than not, the culprit is hiding in plain sight: excessive heap allocations. In this guide, I'll show you exactly how Go decides where to put your variables, why it matters for performance, and how to fix the most common allocation mistakes I've seen in production codebases. The Hidden Cost of Memory Allo

We've just released Refinery 3.0, a performance-focused update which significantly improves Refinery's CPU and memory efficiency.

What makes Go developers truly effective? In this guest post, John Arundel shares ten practical “commandments” of Go excellence – timeless lessons for writing cleaner, safer, and more maintainable Go code.

Some of my favorite tidbits from the past year of working with Go.

Concurrency breaks ordering by design, but sometimes we need both. Explore three methods to preserve order in concurrent Go applications, from standard ReplyTo channels to sophisticated permission passing, with benchmarks and real-world trade-offs.

Why do Go developers obsess over variable names, error handling, and interfaces, even when your approach does the job, too? Whether gently or not so gently, they'll remind you there's a right way to write Go. In this talk, I walk through frequent code review comments to show what looks like nitpicking is a window into Go's design philosophy. These aren't arbitrary style debates; they're about writing clear, deliberate, and unapologetically pragmatic Go. You leave with a better understanding of the "why" behind the rules and how embracing them can sharpen your code. GoLab 2025, Florence https://konradreiche.com/

False sharing killed our performance. Data-oriented design saved it. Learn cache lines and NUMA.

Go Goroutine Synchronization: a Practical Guide Go offers two complementary concurrency styles: message passing via channels and synchronization of shared memory via locks and atomics. Understanding …

within Rust is a smaller language struggling to get out

The peak of hype isn’t the best moment to reflect on AI. Will it take your job, or is it the next fad like NFTs? Are AI startups ridiculously overvalued, or are the companies that sleep on AI doomed? Time will tell. LLMs are far from perfect, but I’m excited they’re here anyway. Not because of a silly promise to make me 10x more productive, but because they can solve some problems that were previously unsolvable.

Go's data race detector can miss possible races in executed code when using mutexes

The ultimate collection of practical Go programming examples, code snippets, and recipes for building efficient and reliable applications with Golang

Learn more about why developers end up with deeply recursive Go code and what can be done to mitigate stack exhaustion issues.

How many rabbit holes can tracing a system call in Go lead you into?

We rolled out Go 1.24 and saw a memory regression. Here's how we dug into system metrics, uncovered a bug in the runtime allocator, and worked with the Go team to help fix it.

Performance comparison of different fan-in implementations in Golang

The Integrity Data Platform team at Grab rewrote a QPS-heavy Golang microservice in Rust, achieving 70% infrastructure savings while maintaining similar performance. This initiative explored the ROI of adopting Rust for production services, balancing efficiency gains against challenges like Rust’s steep learning curve and the risks of rewriting legacy systems. The blog delves into the selection process, approach, pitfalls, and the ultimate business value of the rewrite.

This cheat sheet provided basic syntax and methods to help you using Go.

Write cleaner, stronger code by embracing Go’s error-handling philosophy.

We will see how to build a MapReduce system from scratch (its workings as well)

Go applications can implement graceful shutdown by handling termination signals (SIGTERM, SIGINT) via os/signal or signal.NotifyContext. Shutdown must complete within a …

An explainer for developing single-page applications using only vanilla techniques.

A technical deep dive into debugging zombie processes in a Go and Docker setup, detailing how I fixed a server crash caused by Node.js process leaks in Stormkit. Learn about process groups, SIGCHLD handling, and using Tini for zombie reaping.