Generic methods in Go 1.27, and the one thing they still can’t do
Go 1.27 lets a method declare its own type parameters. Where that cleans up real code, and why a generic method still can’t satisfy an interface.
Writing on backend systems, AI agents, and designing software that lasts.
Long-form notes on what I build and teach: services, remote desktops for HPC, agent tooling, migrations and debugging, collected in chronological order.
Why your async trait still can’t go behind dyn, and what Rust is doing about it
async fn in traits has been stable since Rust 1.75, but dyn Trait still rejects it. Why the compiler says no, the workarounds I reach for today, and the 2026 plan to fix it.
Go 1.27 can find your leaked goroutines. Here’s how it knows
Go 1.27 makes the goroutineleak profile generally available. How the garbage collector spots goroutines that can never wake up, how to read the profile, and what it still can’t see.
Where the memory goes in a Tokio service
An async Rust service that grows to gigabytes rarely has a single leak. The four places I look: future sizes, queues without backpressure, the allocator, and tasks that never finish.
Where the milliseconds go in a remote desktop for HPC
A remote desktop is a pipeline: schedule, capture, encode, transport, decode, present. How I find which stage is slow, and when GPU decoding is worth it.
Building an MCP server for debugging remote desktop sessions
What the Model Context Protocol is, why it suits root-cause analysis, and the rules I follow when designing tools an AI assistant uses to debug remote desktop sessions.
Letting AI agents do the boring parts of a service migration
Agents are good at reading a lot of code and making the same change many times. How I split a migration between agents and people, and the guardrails that keep it safe.
Zero-downtime migrations from legacy services to Go and Kotlin
How to replace a legacy service while it keeps serving traffic: a routing layer, recorded behaviour, shadow traffic, gradual cutovers and a rollback you’ve actually rehearsed.
Idempotent consumers: the Kafka lesson I keep relearning
Kafka delivers at least once, so your consumer will see duplicates. The patterns I use so that every event is processed exactly once in effect.
What teaching 100+ students taught me about explaining code
Lessons from more than 250 hours of teaching and a year of mentoring developers, and how they changed the way I review, name and design code.
Mastering Precision: Understanding PostgreSQL’s NUMERIC Type and How It Stands Out
What PostgreSQL’s NUMERIC type is, how it differs from the floating-point types, when exact precision is worth its cost, and tips for using it well.
Golang and Scalability: Building High-Performance Systems
Why Go suits scalable backends: its concurrency model, real-world case studies, the patterns that help services scale, and how to optimise performance.
Advanced Tools for Boosting Productivity in Go-lang
A tour of Go tools beyond go run and go test: golangci-lint, Testify and Ginkgo, pprof and trace, dependency graphs, code generation and documentation.