All posts
Long-form notes on software, distributed systems, and the craft of building. Shipping one a week.
Your Queue Won't Drain: The Arithmetic of Backlog Recovery
A healthy-looking consumer fleet can sit on a 3-million-message backlog that never shrinks. These are my notes on the arithmetic behind it: surplus = capacity − arrival, drain = backlog ÷ surplus, and why a fleet sized for steady-state has zero recovery capacity. I built a small TypeScript simulator to watch retry amplification park a correctly sized fleet in a metastable failure, and worked out when shedding beats draining.
Backpressure Is a Contract Every Caller Must Honor, Not a Setting
A bounded queue in one service does nothing if the caller above it keeps pushing. These are my notes on backpressure as an end-to-end contract: what the callee owes, what every caller owes back, and why the Azure OpenAI retry-amplification incident is what a broken clause looks like at hyperscale.
The Bug That Wouldn't Compile: Porting a Reordering Mistake to Hydro
I planted an arrival-order bug in a hand-rolled Rust fan-in aggregation, reproduced a 51% undercount with a seeded shuffle, then ported the same logic to Hydro 0.17-alpha. The unordered merge refused to compile my non-commutative fold — these are my notes on what that guarantee is, what manual_proof! only attests, and when the seam costs are worth paying.
Architecture as Code with Structurizr DSL: A C4 Workspace Both a Reviewer and an Agent Can Read
I committed a Structurizr DSL workspace next to a Kotlin/Spring billing service and wired ArchUnit into Gradle so CI fails the moment the code drifts from the C4 design. Here is the workspace.dsl, the test that backs it, and what changed when a coding agent could read both files instead of guessing from packages.
Engineering Before Inference: The Question Zero Token Architecture Is Actually Asking
Lately I keep hearing a sentence that would have been absurd three years ago: "I can't do it now — I ran out of tokens." These are my notes from digging into Zero Token Architecture — the idea Kelsey Hightower took from a throwaway post to a PlatformCon keynote — and the principle I want to build on it: every AI call is an architectural decision, and the costs that matter most were never the tokens.
When SQL Is Enough for Streaming: What Incremental View Maintenance Guarantees — and What It Refuses
The 2026 pitch is that a hand-written stream job collapses into one CREATE MATERIALIZED VIEW, so I built one in RisingWave and spent my study time trying to break it. These are my notes on the consistency the view actually delivers as events arrive, why every join in it is a standing memory bill, and the queries that refuse to be incremental — with a Node consumer riding the view's changefeed over the plain Postgres protocol.
Java 26 Landed: The Features to Track Before the Java 29 LTS
Most backend teams run only the LTS lines, so Java 26 looks skippable. It is not — it is the clearest preview of what the Java 29 LTS will contain. These are my notes on what is already final (AOT object caching with ZGC, a faster G1, HTTP/3), the one preview I would rewrite code for (Lazy Constants, with a runnable example), and the integrity change that will break builds.
The Shift Zone: The Backend Is Becoming Software That Sleeps
I have watched state break the monolith, then microservices, then serverless — and I have spent months reading the changelogs that convince me the third break just got fixed. These are my notes on the 2024–2026 convergence of ephemeral compute and durable state, why the billing model is the tell, and the A/B experiment this post commits me to: rebuilding a problem I already solved in Spring Boot on the new substrate, with the numbers published either way.
The Server Is a Sync Relay Now: Architecting Around Client-Owned State
At QCon London 2026 Kleppmann described local-first as the best of Google Sheets and the best of Git, and this year the sync engines shipped. From my reading of Electric, Zero, and LiveStore side by side, these are my notes on what changes when the client's copy becomes primary: where conflicts resolve, what the server still owns, and the merge-vs-refuse line that decides which apps must never be built this way.
Turning Repo Maintenance into Markdown: Keeping a Rust Codebase Alive with Agentic Workflows
Long-lived repositories drift: deprecated components linger, layers bleed, and tests miss the functions that actually break. In my own study I turned three recurring chores into scheduled markdown workflows the repo runs on itself, then wrote up what I learned about capping blast radius, pairing LLM checks with deterministic scans, and letting agents draft shapes while I write the substance.