My Code Works… I Have No Idea Why

A Small White Rectangle and a Black Screen From 1999

While going through old notebooks from school, I found a few pages filled with handwritten Pascal code. No frameworks. No engines. Just a black screen and a tiny white rectangle bouncing from one border to another. It was simple. Almost primitive. But it worked. At the time, making something move on the screen felt like... Continue reading

When a Baby Becomes Your New Product Manager

Before the baby, I thought my life was reasonably well-structured. I had plans, goals, a roadmap, and a strong belief that with enough discipline I could fit everything into a day. Work, side projects, learning, rest – all neatly stacked, like well-written code. Then a baby shipped to production. There was no migration plan, no... Continue reading

Fighting Developer Burnout: Personal Stories, Practical Tips, and the Occasional Panic Commit

Why burnout is the silent bug in our profession Every developer has shipped code with a bug that quietly lurks in the shadows, passing tests, dodging code review, and waiting for the worst possible moment to reveal itself. Burnout is the same kind of bug, except it doesn’t crash your app – it crashes you.... Continue reading

Why We Need to Refactor Our Thoughts

We spend our days untangling spaghetti code, hunting down elusive bugs, and arguing with compilers that “this is definitely a String, I swear.” Yet our own heads often look like a legacy repository abandoned in a dark corner of GitHub – full of hacks, forgotten TODOs, and mysterious side-effects. If you expect peak performance from... Continue reading

ORM is Evil, but I Have No Proof

A Confession During Therapy I use ORMs. Every day. For years. Sometimes I even think they’re convenient. Forgive me, Father, for I have mapped. Last week I actually muttered “let the framework handle it” with a straight face – that’s when my team staged an intervention. My therapist suggested I write down my feelings instead... Continue reading

Taming the Thread Zoo: Building Lock-Free, GC-Friendly Concurrency in Kotlin

Grab a chair, refill your caffeine reservoir, and let’s talk about that four-letter word we all pretend not to hate: lock. You know the drill: everything runs fine in staging, but the moment real traffic turns up, a single hot lock starts playing king-of-the-CPU-hill while your tail-latency graph draws modern art. At that point management... Continue reading

The TTL-Driven Coroutine Cache: Because Life Is Too Short for Stale Data

I decided to publish some interesting libraries I develop for internal experiments – after all, one can only watch their side projects gather dust for so long before letting them roam free on GitHub. This time, I want to show off a TTL-based in-memory cache for coroutines, complete with a neat annotation-based code generation trick... Continue reading

Ultra-Precise Time-Synchronization & Timestamping in Kotlin

Continuing my saga of posts about squeezing every last drop out of Kotlin like it’s an overripe lemon of potential. 🥴 Just a friendly warning: don’t even think about using this in production until you’ve at least test-driven it in a few less judgmental environments. You know, like staging, or your cat’s laptop. Nothing says... Continue reading

Building a Sub-100 µs Matching Engine with Kotlin Coroutines

In the world of high-frequency trading (HFT), every microsecond counts. Small inefficiencies can quickly snowball into significant costs or missed opportunities. With Kotlin’s robust coroutine model, we can harness lightweight concurrency to power a matching engine that can respond within sub-100 microseconds. In this post, I’ll walk through the design considerations, coroutine architecture, and performance... Continue reading

Attack of the Clones: How Kotlin Design Patterns Save the Day (Again)

If you’ve ever had the pleasure of working with generated classes—whether from Protobuf, Swagger, or yet another “magical” schema tool—you’ll know they’re about as customizable as a locked-down corporate laptop. The result? Multiple classes that all do basically the same thing (e.g., PersonA, PersonB, PersonC) but refuse to share a single interface. In Kotlin, this... Continue reading