[ Blog_Posts ]

NATS vs Kafka vs MQTT: Same Category, Very Different Jobs

All three are 'messaging systems.' None of them is interchangeable with the others. A practical breakdown of NATS, Kafka, and MQTT — by the actual design axes that determine which one breaks when you misuse it.

2026-02-24 Harrison Guo 9 min read distributed-systems messaging nats kafka mqtt event-driven iot architecture backend-engineering system-design

Docker × Kubernetes: What They Really Changed (It's Not What You Think)

Docker is not a virtual machine. Kubernetes is not a container tool. Fifteen years in, both are misunderstood — and misused — as a result. A working engineer's explanation of what they actually changed.

2026-02-21 Harrison Guo 10 min read docker kubernetes containers devops infrastructure cloud-native backend-engineering system-design cgroups linux-namespaces

Scale-Up vs Scale-Out: Why Every Language Wins Somewhere

The 'which language is fastest' benchmark wars miss the real question. Rust, Go, Java, and Python aren't competing on the same axis. They're tuned for different scaling strategies — and picking the wrong one costs you years.

2026-02-20 Harrison Guo 9 min read programming-languages system-design scale rust golang java python architecture backend-engineering performance

Testing Real-World Go Backends Isn't What Many People Think

The unit-vs-integration framing is a junior lens. Production Go backends need a different taxonomy: deterministic tests, contract tests, race tests, and fidelity tests. The ones that actually catch production bugs.

2026-02-18 Harrison Guo 10 min read golang go testing backend-engineering distributed-systems race-conditions contract-testing production software-engineering

Observability and Cost Attribution: Why One Pipeline Isn't Enough

Tracing systems optimize for signal-to-noise. Billing systems optimize for accuracy and auditability. They look similar and they are not the same thing. A dual-path architecture for running both without cross-contamination.

2026-02-15 Harrison Guo 10 min read observability billing cost-attribution opentelemetry distributed-systems architecture backend-engineering system-design metrics tracing

Go Context in Distributed Systems: What Actually Works in Production

context.Context is not documentation, not a metadata bag, and not optional. A production-hardened guide to cancellation propagation, the background-goroutine trap, and the patterns that keep services alive when downstreams slow down.

2026-02-13 Harrison Guo 9 min read golang go context concurrency distributed-systems cancellation goroutines errgroup production backend-engineering

Go's Concurrency Is About Structure, Not Speed: chan and context as Lifecycle Primitives

After a few years writing production Go, I stopped thinking of chan as a data pipe and context as a parameter. They're both lifecycle primitives — chan draws the boundary of 'how many alive', context draws the boundary of 'when to die'. Here's why that mental model changes the code you write.

2025-11-21 Harrison Guo 10 min read golang go concurrency channels context backpressure worker-pool distributed-systems backend-engineering go-design

IronSys: A Production Blueprint for Modern Concurrency

After Four Pillars of Concurrency, the natural question: what does a system actually look like when it uses all of them deliberately? IronSys is a composite blueprint — the concurrency architecture I'd build today if I were starting over, with the trade-offs each choice buys.

2025-10-22 Harrison Guo 10 min read concurrency system-design golang architecture distributed-systems backend-engineering csp actors production

From Locks to Actors: The Four Pillars of Modern Concurrency

Most engineers still reach for the mutex. That's one of four options, and usually not the best one. A working engineer's map of shared-state, CSP, actors, and STM — and when each is the right tool.

2025-10-20 Harrison Guo 10 min read concurrency system-design golang erlang rust distributed-systems csp actors stm backend-engineering

Why Go Handles Millions of Connections: User-Space Context Switching, Explained

Go isn't magic and it isn't faster than Java. It just stops asking the kernel to help. A first-principles look at goroutines, 2KB stacks, and why high-frequency trading engines chase the exact same answer.

2025-10-13 Harrison Guo 7 min read golang go concurrency distributed-systems goroutines scheduler performance user-space-networking kernel-bypass backend-engineering

[ Blog_Posts ]

[ Connect_With_Me ]