The Web is much bigger than we think.
“Dojo has already won.” said Alex Russell.
We sat at a long chest-high table on the top floor of 543 Sansome st in San Francisco. The top two floors had been renovated and decked out by Mitch Kapor to house several of his non-profit adventures, including the Open Source Applications Foundation which I had joined shortly after Scott Rosenberg finished writing a book about the endeavor, Dreaming in Code.
Dojo’s success wasn’t just good for Alex and the project’s contributors, it was good for The Web. Traditional application developers were still writing for the Desktop even after it was clear The Web was the future. This was because they didn’t have the tools they needed to write “real applications.” Dojo was just the thing they needed to bring them to The Web.
- A module system for isolated functionality and ecosystem building.
- A bundler, for packaging all these together, along with a dev server that loaded each file separately for debugging (source maps would not exist for another 5 years).
- A builtin minifier (minification was rare and the only implementation was in Java).
- A complete workflow for templating and styling and an MVC workflow.
Sure, Dojo took a little more work, a little more engagement and education on the part of its users to get setup, but the benefits were big enough that it didn’t really matter.
And then… jQuery happened.
React is one of the most powerful tools for building web applications ever invented.
It’s used not only by hipster San Francisco startups but gigantic companies like Facebook. Among its contemporaries like Ember, Vue.js, and Angular, it leads the pack.
React combines all the modern techniques necessary for building “real applications” in JS that compete with native. These include:
- A builtin compiler, builder and bundler.
- A templating system built right into the language and facilitated by the compiler.
- A component system by which an ecosystem can be built.
- A complete workflow following the lifecycle of an application and user interactions for rendering and re-rendering.
- A virtual DOM that offers the necessary performance for large applications.
So assured is its success that IBM and Google shortly banned its use internally over patent concerns before React altered its licensing.
Before I talk about what I think the future might look like, it’s important to be clear about the past.
What happened is simple, the metrics for success they had operated under changed. Being considered a “successful JS framework” moved from “nearly all new big web applications” to “70% of the websites on the internet.”
For all its success, jQuery never succeeded in building an ecosystem around its plugin architecture (Dojo had a larger collection of AMD modules working on its module system than jQuery had plugins). What it did do was get included on nearly every website on the internet. Dojo could never compete with that metric.
“Dojo already did it” became a common comment during conference talks for the next ten years. And it was true, Dojo did everything we’d re-invent for the next decade, but this time to work without all the setup and ceremony of using Dojo.
For those closest to Dojo this became an identity. They saw the future before everyone else, they even built it, and everyone else is just playing catch up.
The Web didn’t win because it was the favorite among enterprises and “real developers.” It won because it scaled down better than it scaled up. It won because it amateurized software development and unlocked the creativity of an entire generation of programmers that couldn’t participate in software until The Web.
As our community has developed our metrics for success in JS have shrunk back to something like they were for Dojo. The kinds of barriers Dojo had to new users, like needing a big toolchain to get started, are now just common practice within the confines of the JS Community. We no longer even consider it a possibility that a new library or framework could cover 70% of the web.
But I think something like that is coming.
We’ve ignored a large portion of The Web’s community for a long time because evolving our ecosystem in npm was at odds with scaling down to a simple <script> tag. That may have changed.
React may have already won, but it won’t be considered as such for long if the metrics for success change out from under it. For that to happen we wouldn’t even need new metrics for success, we would only need to return the metrics we used to have.