React is the new Dojo
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.
Alex went on to explain that, once you get out ahead of the competition far enough nobody can catch up. Dojo was, by far, the leader of the “JavaScript Front-End Framework” space. It had succeeded in moving past “web people” and attracted traditionally Desktop oriented developers. It was so far ahead of its competitors, so guaranteed to be the basis of the next generation of applications, that even IBM was now on board.
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.
Dojo was the only framework that integrated the necessary tooling for large applications. These were a first in JavaScript and included:
- 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.
Dojo did win. The metrics for success that Dojo operated under were the same as its contemporaries. It succeeded in getting large scale adoption for “big applications” for a time and it moved a lot of Desktop developers away from other languages into JavaScript.
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.
The JS community has matured a lot in the last decade. As this happened it also drifted farther away from what we used to refer to as “The Web Community.” Before JSConf, the only conferences and community you could find around The Web mixed together PHP, Wordpress, and jQuery people in the same space. When jQuery “won” it won across the entire web community, not just JavaScript, because there was hardly anything you could consider the “JS Community” at the time.
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.
