Revisiting Technology Choices in Modern Development
Technology is in a constant state of flux. In software development, new tools and frameworks emerge continuously, while programming languages themselves evolve—or entirely new ones are born. Past decisions and assumptions must therefore be regularly revisited. The worst mistake one can make is to cling to a direction based on outdated beliefs.
Evolution, Not Revolution
This isn’t about rewriting all your code annually, nor is it about dismissing everything that came before. It’s about aligning with a forward-looking approach—one that’s inherently temporary.
Why Reassess Technology Choices?
If the current path works, why change? Simplicity favors inertia, but several compelling reasons demand otherwise. Here, I’ll avoid diving into specific frameworks or libraries, focusing instead on higher-level principles.
New programming languages arise to address the shortcomings of existing ones—not just in security, but also in simplicity. How quickly can developers adapt? What performance gains are possible? Can we save time?
Personal Journeys: Go, Rust, and Zig
For years, I’ve primarily worked with Go and TypeScript. Go excels in simplicity, blazing-fast compilation, backward compatibility, and cross-platform support. Compared to cumbersome C++ build environments, it felt revolutionary, with tooling that just worked.
Yet, Go has its pitfalls—not due to language limitations, but because its apparent simplicity leads some developers to disregard its idioms. Go projects often lose their idiomatic clarity as influences from other languages creep in. Optimization potential is squandered when the Go runtime is only superficially understood. This is a cultural problem with no built-in solution.
My first attempt with Rust years ago failed due to its immature toolchain. By 2021, however, Rust had matured impressively. But as I delved deeper, I found fragmentation: no single “Rust way” exists. Macro styles vary, and developers freely mix imperative or functional paradigms—amid a sometimes dogmatic community. Still, I haven’t abandoned Rust. It feels like a generation away from unification, where clearer conventions might emerge beyond relying solely on the compiler’s strict checks.
Zig, by contrast, captivated me immediately as a modern successor to C. Lightweight, dependency-free, and
cross-platform, it shares Go’s ethos. Yet, in practice, Zig feels incomplete. Tools like Bun (written in Zig) prove
its potential, but something intangible holds me back—despite its brilliance (e.g.,
comptime).
Diversity as Strength: Microsoft’s Approach
No single ecosystem is mandatory. Microsoft exemplifies this: they’re rewriting critical tools like
sudo and edit in Rust, while porting
TypeScript to Go. Diversity attracts varied talent—and your
technology choices must align with hiring realities.
Conclusion: The Right Choice for Now
Choosing a language or stack is always a snapshot in time, shaped by project needs, team skills, and technological maturity. Yet while code endures, environments shift. Security standards and performance expectations evolve.
Go, Rust, Zig, and TypeScript prove there’s no “perfect” tool—only the right one for specific problems:
- Go thrives on simplicity but suffers when developers neglect its idioms.
- Rust delivers unmatched safety at the cost of complexity and fragmented styles.
- Zig could replace C but must first mature its ecosystem.
- TypeScript rescues JavaScript projects while introducing new dependencies.
The art lies not in dogma, but in periodic reflection:
- Question assumptions—Have needs changed? Are better tools available?
- Weigh trade-offs—Safety vs. simplicity, performance vs. maintainability.
- Experiment incrementally—Rewrites are risky, but small proofs-of-concept expand horizons.
Microsoft’s strategy—Rust for security, Go for productivity, TypeScript for the web—shows that diversity is a feature, not a bug.
In the end, the goal isn’t to find the “best” language, but the right one for now—with the humility to revisit that answer tomorrow.
“The only wrong decision is the one you never rethink.”