You know that feeling. You press ‘Save’, and your editor hangs for a full second. A blink. A breath. But it’s not your hardware. It’s not your network. It’s the layer cake of abstractions we’ve been baking for a decade.
Microsoft just rewrote the TypeScript compiler in native code—Rust, Go, C++—and it’s 10x faster. The internet is celebrating. But read the fine print. That 10x isn’t a breakthrough. It’s a confession.
We’ve been burning CPU cycles for decades, and we called it progress.
Every millisecond of lag in your editor, every spinning wheel in your browser, every bloated node_modules folder—they’re monuments to our obsession with developer convenience. We chose JavaScript, then TypeScript, then Babel, then Webpack, then Vite—each layer adding a tax. A tax you pay every time you hit ‘compile’.
Here’s the uncomfortable truth: the web technologies we worship—portable, dynamic, easy—are an ecological disaster. Not just for the planet (though that’s real), but for the very soul of computing. We’ve convinced ourselves that a 10x slowdown is normal. That wasting 90% of your machine’s potential is just ‘the cost of doing business.’
Developer experience (DX) became a religion. And we’re the sacrifice.
I’ve watched teams choose a slower framework because ‘it’s more productive.’ I’ve seen startups burn VC money on cloud compute just to run a web app that could have been a few static files. The TypeScript rewrite is a mirror: it shows us that the original JavaScript toolchain was so inefficient that a native rewrite could deliver 10x performance without changing the language. That’s not engineering. That’s a self-inflicted wound.
Now, before you call me a Luddite, hear me out. I’m not saying we should all go back to assembly. But we need to stop pretending that every new abstraction is a gift. The 10x speedup isn’t a miracle—it’s a correction. And it’s a warning: the next time you reach for a framework, ask yourself: Who is this really for? Me, or the user?
Neutrality is death. Software is too slow. And we built it that way, on purpose.
The real innovation wouldn’t be a 10x faster compiler. It would be a culture that values the end user’s time as much as the developer’s. Until then, every ’10x faster’ headline is just a eulogy for the performance we threw away.
FAQ
Q: Isn't a 10x speedup just a good thing? Why frame it as a confession?
A: A 10x speedup is objectively good—but it reveals how bad the original was. The confession is that we accepted a 10x slowdown as normal for years. That's not innovation; it's digging out of a hole we dug ourselves.
Q: What's the practical takeaway for a developer?
A: Pause before adding another abstraction. Ask: will this make the user's experience better, or just mine? If you can't measure the performance cost, you're probably paying it in the user's time.
Q: But aren't web technologies necessary for cross-platform and rapid iteration?
A: Yes, but that doesn't excuse the waste. The tension is real: portability vs. performance. The TypeScript rewrite shows we can have both—if we're willing to rewrite the tools we assumed were 'good enough.' The contrarian take: maybe we should stop building everything on the web.