Quoting Mitchell Hashimoto

Origin: Why discuss the 'disposability' of programming languages now? Hashimoto's commentary stems from Bun (a popular JavaScript runtime) recently announcing a rewrite of its core in Rust. While this is a technical news item in itself, Hashimoto captures a deeper insight: this is no longer just another 'project X rewritten in Rust' story, but reveals a fundamental shift in modern toolchains—programming languages are being demoted from 'strategic choices' to 'implementation details.' Breakdown: What does language fungibility actually mean? Historically, choosing a programming language was like marriage: once decided, the entire tech stack, team skills, and ecosystem became deeply entangled, with extremely high migration costs. Languages like Java, C++, and Python once 'locked in' enterprises for decades. But Hashimoto observes that this lock-in is dissolving. The Bun case is particularly compelling: it started with Zig, is now rewritten in Rust, and Hashimoto believes 'it could probably be in any language they want in roughly a week or two.' The logic behind this is that modern software architecture—especially in infrastructure and toolchains—is becoming increasingly modular, reducing the coupling between core algorithms and language-specific features. More importantly, AI-assisted programming is accelerating this process. When AI can rapidly translate code and generate idiomatic patterns for different languages, the barriers to migration drop significantly. Trend Insight: AI is reshaping the developer-tool relationship This reveals a deeper trend: in the AI era, a developer's core value is shifting from 'mastering specific tools' to 'rapidly assembling solutions.' Language fungibility is merely a symptom; the essence is the 'consumerization' of tool selection—we choose languages like screwdrivers, picking them up when needed and discarding them afterward. Hashimoto's comment is especially noteworthy because tools he created, like Terraform and Vagrant, were once deeply tied to specific language ecosystems. The fact that even he acknowledges the 'disposability' of languages indicates this has become industry consensus. It also explains why Rust, despite its power, hasn't achieved the kind of monopoly C++ once did—when migration costs are low enough, any language is just a 'temporary optimal solution.' Practical Value: What does this mean for developers? First, stop over-investing in 'language religious wars.' When choosing a language, focus more on: 1) suitability for the current problem; 2) team ramp-up speed; 3) the modularity of the ecosystem. Second, cultivate 'language-agnostic' architectural thinking—design systems so that core logic remains relatively independent of language-specific features. Finally, embrace AI-assisted migration tools, which are transforming language switching from 'rewriting' to 'translation.' Counterintuitive: Fungibility doesn't mean languages are unimportant A commonly overlooked angle is that language fungibility might actually make good languages more important. When migration costs are low, developers are freer to choose the most elegant and efficient tools, rather than being stuck with 'good enough' options. The reason Rust could be quickly adopted by Bun is precisely because its memory safety and concurrency model genuinely solve pain points. So this isn't the death of languages, but a redefinition of their value—from 'irreplaceable foundations' to 'replaceable high-quality components.'