Writing Testable Go Code Without Mocking Everything
Real implementations over mocks, test fixtures that work, and design patterns that make code testable without generating mock files for every interface.
Posts
Profiling Memory Allocations in a High-Throughput Go Service
How we reduced GC pauses from 50ms to 2ms by finding hidden allocations. Practical pprof techniques, escape analysis, and the optimizations that actually matter.
Worker Pools and Bounded Concurrency in Go
Practical patterns for controlling concurrency: worker pools, errgroup, semaphores, fan-out/fan-in, and backpressure. How to process work concurrently without overwhelming your system.
Graceful Shutdown in Go Is Harder Than You Think
Handling in-flight requests, Kafka consumers, database connections, and Kubernetes termination signals correctly. The details that tutorials skip.
Error Handling Strategies Beyond if err != nil
Structured errors, error wrapping done right, sentinel errors vs behavior checking, and patterns that make debugging production issues actually possible.
Dependency Injection in Go Without Frameworks
Manual DI, functional options, Wire code generation, and why Go doesn't need Spring-style containers. Practical patterns for building testable, maintainable applications.
Why Our Microservice Needed a Circuit Breaker (And How We Built It)
Real latency cascades we encountered, how they took down our system, and the circuit breaker implementation that saved us.
When to Go Distributed: Real Talk on Building Systems with Go
After years building distributed systems, here's my honest take on when you should consider the complexity, and why Go excels when you do.
Context Propagation Patterns in Large Go Codebases
When to pass context, when not to, and the common mistakes that lead to leaked goroutines, missed cancellations, and debugging nightmares.
Structuring a Go Monolith So It Can Become Microservices Later
Practical module boundaries, package organization, and the patterns that make future decomposition possible without rewriting everything.
Simplified Clean Architecture in Go
A practical guide to implementing Clean Architecture in Golang with real examples and best practices for building modular, testable backend services.
Building REST APIs with Go
Learn how to build production-ready REST APIs using Go's standard library and best practices.
Understanding Go Interfaces
A deep dive into Go's interface system and how it enables polymorphism and flexible code design.
Getting Started with Go
An introduction to the Go programming language and why it's great for building web applications.
Designing Service Boundaries and API Contracts
Where you draw service boundaries — and how you treat the contracts between them — decides whether a system is genuinely decoupled or a distributed monolith wearing microservice clothes. On data ownership, coupling, and evolving contracts without breaking consumers.
ClojureScript for React Developers
If you already know React, most of ClojureScript is closer than you think. Reagent is React with immutable data and hiccup instead of JSX — here's the mental map, the interop story, and why reference-equality re-rendering is the quiet win.
Redux and re-frame: Two Takes on Front-End State
Redux (React/JS) and re-frame (ClojureScript) start from the same idea — one immutable app state, pure updates, derived views — and diverge in instructive ways. What each gets right, and what re-frame's effects and interceptors add.
GraphQL in Go: Killing N+1 and Shrinking Payloads
The two problems every GraphQL server hits once real clients arrive: the N+1 query explosion from nested resolvers, and unbounded query cost. How to fix both in Go with dataloaders and complexity limits.
Choosing Between REST, gRPC, and GraphQL
Three ways to expose an API, three different bets. A practical comparison of REST, gRPC, and GraphQL across contracts, transport, client fit, evolution, and caching — with the concrete conditions under which each is the right call.
Datomic for Data-Heavy Domains: The Database as a Value
What Datomic gives a data-heavy domain that a traditional database doesn't: the atomic datom, schema as data, immutable database values you query as pure functions, time-travel and audit for free—and an honest look at where it bites.
Redis Caching Strategies That Actually Moved the Needle
Cache-aside vs write-through, TTLs with jitter, and the cache stampede that takes your database down at the worst possible moment — with Go and Redis, and an honest look at the invalidation problem nobody escapes.
Performance in Data-Heavy Clojure: Transducers, Transients, and core.async
Making Clojure fast on large datasets: why lazy-seq pipelines allocate, how transducers and transients cut that to near zero, killing reflection in hot loops, and using core.async pipelines for I/O-bound fan-out with backpressure.
REPL-Driven Development: How I Actually Write Clojure
REPL-driven development is not 'a better console' — it's editing a live program. How I build functions incrementally against real data from inside my editor, using rich comment blocks and tap>, and where the workflow bites.
The BFF Pattern in Clojure: Typed Contracts for a Data-Heavy Frontend
Building a backend-for-frontend in Clojure with Ring, Reitit, and malli: data-driven routing, typed HTTP contracts without a static type system, parallel fan-out to downstream services, and graceful degradation when one of them is slow.
PostgreSQL Indexing for High-Volume Services
A practical guide to indexing Postgres under load: how B-tree indexes actually get used, why composite column order matters, covering and partial indexes, reading EXPLAIN, and the write-side cost that makes 'just add an index' the wrong default.