Wirth’s Law still hits hard in 2025. It's like the ghost of your first CS prof whispering "I told you so" every time an app eats 500MB to display a list of items.
We were supposed to use better tools to build better systems. Instead, we used faster hardware to make it acceptable to ship ever-more bloated layers of abstraction. Everything depends on everything else, and no one knows what any of it does, just that it “works on my machine.” Until it doesn't.
It’s not just about performance — it’s about comprehensibility. You used to be able to hold a system in your head. Now? Good luck tracing anything across 8 layers of indirection, six config files, a microservice mesh and a runtime whose lifecycle even the maintainers don’t fully understand.
I find myself drawn to projects like Red[1], MIR[2], or even Metamath[3] — not because they’re production-ready silver bullets, but because they remind me what it’s like to work on systems that are conceptually finite. With MIR, you get a JIT compiler backend that’s tiny and knowable — and that still punches way above its weight. There’s elegance in understanding where every byte and cycle goes.
The rebound effect of Moore’s Law is real: more resources led to more indirection, which led to more tools, which led to more churn. And now we’re entering the AI era, where tools can generate “working” code faster than we can understand what it’s really doing.
And sure, it feels productive — but something subtle gets lost when we stop thinking through the system as a whole.
We’ve outsourced understanding to the machine.
Now we just hope it’s right.
Adding layers of indirection and abstraction can solve all problems – except for the fatal problem of complexity and bloat resulting from having too many layers of indirection and abstraction.
30 years ago, without an SSD, my Pentium box booted to the desktop in 60 seconds — that’s roughly 5 billion CPU cycles at 75 MHz.
Today, with blazing-fast SSDs and CPUs running at 4+ GHz, a typical PC boots in around 10 seconds — that’s 50+ billion cycles per core.
One of my teachers used to say: "In computing, 3 seconds is an eternity."
These days, that’s enough time for 20 billion AVX-512 instructions.
It’s hard to accept that anything not truly compute-intensive needs more than that.
Realistically, we should be able to hit 300 ms latency across the entire UX — and yet we don’t.
Wirth’s Law still hits hard in 2025. It's like the ghost of your first CS prof whispering "I told you so" every time an app eats 500MB to display a list of items.
We were supposed to use better tools to build better systems. Instead, we used faster hardware to make it acceptable to ship ever-more bloated layers of abstraction. Everything depends on everything else, and no one knows what any of it does, just that it “works on my machine.” Until it doesn't.
It’s not just about performance — it’s about comprehensibility. You used to be able to hold a system in your head. Now? Good luck tracing anything across 8 layers of indirection, six config files, a microservice mesh and a runtime whose lifecycle even the maintainers don’t fully understand.
I find myself drawn to projects like Red[1], MIR[2], or even Metamath[3] — not because they’re production-ready silver bullets, but because they remind me what it’s like to work on systems that are conceptually finite. With MIR, you get a JIT compiler backend that’s tiny and knowable — and that still punches way above its weight. There’s elegance in understanding where every byte and cycle goes.
The rebound effect of Moore’s Law is real: more resources led to more indirection, which led to more tools, which led to more churn. And now we’re entering the AI era, where tools can generate “working” code faster than we can understand what it’s really doing.
And sure, it feels productive — but something subtle gets lost when we stop thinking through the system as a whole.
We’ve outsourced understanding to the machine. Now we just hope it’s right.
[1] https://www.red-lang.org/
[2] https://github.com/vnmakarov/mir
[3] https://us.metamath.org/
Complexity is the enemy.
Adding layers of indirection and abstraction can solve all problems – except for the fatal problem of complexity and bloat resulting from having too many layers of indirection and abstraction.
What intel (et al.) giveth, Microsoft (et al.) taketh away.
Today’s app developer isn’t the same % person as 30 years ago probably.
If you take something like v8 or the vlc sofware decoder for av1 or nvidia cuda libraries it should be as good as old stuff
I assumed that optimisation of run-time stopped when run-time on a modern computer was judged acceptable.
30 years ago, without an SSD, my Pentium box booted to the desktop in 60 seconds — that’s roughly 5 billion CPU cycles at 75 MHz. Today, with blazing-fast SSDs and CPUs running at 4+ GHz, a typical PC boots in around 10 seconds — that’s 50+ billion cycles per core.
One of my teachers used to say: "In computing, 3 seconds is an eternity." These days, that’s enough time for 20 billion AVX-512 instructions.
It’s hard to accept that anything not truly compute-intensive needs more than that. Realistically, we should be able to hit 300 ms latency across the entire UX — and yet we don’t.