Have we decided that JavaScript is bad?

JavaScript has outgrown itself

JavaScript has cemented itself as the backbone of the modern web. It’s ubiquitous on the frontend and powers a sizeable number of backend services. With software such as Electron, many of the most frequently used desktop applications are web apps under the hood. It’s a language and ecosystem that has grown both with and for the web.

JavaScript shines in the environments it is meant for. The single-threaded environment of a web browser, or lightweight microservices and edge nodes where the main form of concurrency is handling a large number of network requests. When it comes to complex calculations, true multi-core parallelism, or heavy file IO, it starts to struggle. This is of course, the exact kind of environment that tooling requires. Tooling needs to scan and parse thousands of files, traverse large ASTs, hash content, and perform CPU heavy workloads across multiple cores.

For the past decade, we’ve been trying to hack around it. Our tooling has sat on a language never meant for that task. We’ve forced parallelism with workers and forked processes. We pushed Node to load more data into memory than it was ever designed to handle. We’ve created a tooling ecosystem that works surprisingly well given the constraints, which is a massive testament to everyone involved, but we’ve hit a hard limit to its capabilities.

JavaScript has a substantial amount of corporate investment, with almost every software company writing at least some amount of it. Take this GitHub chart showing language popularity for example. At the time of writing, it shows JavaScript as the top language, and TypeScript as the third top language. The JavaScript ecosystem is taking two of the top three places. With that level of adoption, it’s not just a popular language, it’s a critical part of global infrastructure. And critical infrastructure needs solid tooling foundations.

This is maturity

For years, JavaScript has lacked the deep static analysis most mature modern languages have. It’s not for a lack of wanting, it’s just too computationally expensive. The ecosystem is full of compromise. Many linting rules but largely limited to simple validations present within the AST, an extremely comprehensive type system that’s had to compromise on its depth, and control flow analysis that only scratches the surface.

By giving these jobs to languages that are actually built for the task, JavaScript finally has the opportunity it’s never had before. It will finally have the capacity to do the kinds of analysis that the language and ecosystem sorely need. This could include much deeper control flow analysis, or even whole-program analysis.

This is especially important when considering the rise of agentic coding. There’s been recent discussion about how AI agents benefit even more than people when it comes to fast and extensive guardrails and validation. This is something the future of JS tooling will truly allow.

This isn’t just about making the tooling better or faster; this is about giving JavaScript a future. A future as a stable mature language that people can be confident in choosing. This trend in tooling is a sign of long-term investment in the maturity of the platform. It’s a sign that the ecosystem has decided that JavaScript has a place, and that it’s here to stay.

Part of that maturity comes from specialisation. JavaScript is settling into its role as a web language and not being forced to do everything. Rather than suffering from compromised correctness, it can delegate the CPU-heavy workloads to better suited languages and focus on what it does best. JavaScript is not dying; it’s being acknowledged for its actual strengths.

Conclusion

This recent shift to native tooling is the outcome of a language that outgrew the limits of its own tooling. For years, there’s been a mismatch between industry investment and what the tooling could provide. JavaScript is going through necessary specialisation and maturation, accepting its role as the language for the web. In doing so, the JavaScript ecosystem is setup for a future full of stability and correctness. So no, JavaScript isn’t bad. We as an ecosystem have decided that it’s important enough to help it mature. We’re finally taking it seriously.