Flash & the browser wars: a personal reflection and prediction
Earlier this week Adobe announced what most suspected was only a matter of time: the sunset (date) of Flash Player. Many would say its demise was overdue and its continued existence unnecessary in light of modern browsers with rich feature sets (mostly) harmonized through web standards (to say nothing of the ongoing security holes leading to Flash player unfortunately being a primary target for malevolent hackers.) But as I reflected on my history with Flash and web browsers, I realized what Flash attempted to do for the web browsing experience may come full circle someday, but to appreciate it you need to know why Flash became a big deal to begin with. (Spoiler alert: it’s the browsers.)
I’ve been on the web for well over twenty years now, starting with the browser that was birthed just down the road from me, at the NCSA: MOSAIC, which could natively only display text and GIFs. I then graduated immediately to Netscape 1 which, unlike Mosaic, could actually display JPEGs without needing a plugin. (Gasp!) At the time, as a multimedia developer, my interest in this World Wide Web thing wasn’t very significant until 1998 when I first touched Macromedia Flash, a product I would end up leveraging heavily all the way through 2014. Back in the late 90s, I never expected Flash would amount to anything more than a vector animation utility. In hindsight, I was completely wrong because I never expected what would indirectly drive what (I now suspect) resulted in Flash’s ubiquity and dominance on the web: the browser wars.
The browser wars were about who could best reproduce an experience at the receiving end of the World Wide Web, at the client, your personal computing device. As an early web developer, it didn’t take me long to realize that inside each web browser the web page experience delivered to the user was not a centralized one, where everyone is encountering the exact same experience all at the same time. Rather, the web page design is centralized at the server, and a copy of the design and assembly instructions are passed down to the receiving client, but it’s still up to the individual browser application to follow the instructions and recreate (render) that design into the actual “page” the user experiences on his/her device. And since each web browser was made by a different organization with different ideas about how they should work, there was no guarantee that the same design would render the same way on all the different web browsers. And this is what led to each browser maker battling to try to make their product “the one” everyone would use. They all wanted to own the one browser to rule the web experience. For experience designers like me, it was horrible.
So more or less, the browser wars were fought because everyone at the time thought that the future of the web belonged to who could achieve the greatest worldwide adoption of their one browser product — the thought that “one ring would rule them all.” This led to web site designers crafting experiences tailored to their own preferred web browser and putting indicators on the site stating “this site works best in x web browser or best viewed in Y web browser,” essentially burdening the consumer with downloading and installing the browser needed to render the site correctly. And this, of course, was maddening for visitors, who felt like they needed multiple pieces of software just to browse from one site to the next.
Now, in the midst of this browser war, while the browser makers were battling and no good option existed to make the experience consistent and dependable for consumers using different computers, an interesting player swept into the gap: Macromedia Flash — a browser add-on capable of playing back rich experiences in any browser and any platform the same way, a proprietary product controlled by a single company. Now, for as much angst as Flash got toward the end of its life after being acquired by Adobe, I think it has a prominent place in web history because, in the midst of the browser wars, it gave the only cross platform capability to produce rich interactive media experiences that could scale to the user’s screen size and render consistently. And let’s not forget that YouTube was birthed on Flash technology as were most online games that were published onto the young World Wide Web. The type of web experiences we take for granted today were initially made possible because Flash provided the only way for rich experiences to be rendered as designed on nearly every PC, because essentially, Flash Player was its own proprietary experience engine (browser), running independently inside the main browser. And as I once reflected upon previously, having only one company control the engine meant that the experience was always rendered the same, even with backward compatibility. (Experiences I built in 1998 still run as designed today!) So as we bid Flash farewell, we might eek out a little retrospective “thank you” for making the early web tolerable and even showing us what it could become, because in the middle of the browser wars, the alternative at the time was terrible. I’ve often said: no one truly won the browser wars, but the consumers definitely lost.
Today the browser creators have realized the only good solution is to agree to standards which, when adopted by the majority, became the target for how all browsers should perform. And thankfully, this is pretty much where we’ve arrived now, where giving consumers the right experience is the focus. Consumers are finally starting to win, thanks to these reasonably neutral standards adopted by all browser manufacturers. Unlike my early web experience, it often doesn’t matter which particular web browser you use now, because the standards are centralized that define how the each experience should be rendered. However, because of varying browser products and versions, and factoring in the different hardware and operating systems we all use, the designer-intended web experience can still vary greatly for us individually, even with these centralized standards and principles.
But could we be heading toward a place where even having a web browser itself doesn’t matter? Back in August of 2010, in one of my old blogs I made a prediction about where personal computing would go in the future, and that proposed future changes the value of individual browsers on the client device considerably. In short, I suggested that with increased network speeds and more centralized cloud computing capabilities, the storage, processing, rendering, and network functions of personal computing devices would shift to being offered entirely as a collective personal computing service to which we each subscribe, and those personal computing services would be likely offered by the major cloud services players like Amazon, Google, Apple, and Microsoft. In essence your computer device itself would become just a simple input output terminal, like an old telephone, with the real magic happening at the other end in a central service provider to which you subscribe.
If this happens, not only does how we acquire and use software change, how web content is accessed would change as well. Instead of everyone installing different apps and browsers to their personal device, there would exist just one master instance of the browser app in the service cloud. All would consume it the same way, and the experience would be centralized for all. The content would only be rendered according to the rules of that one engine — likely still standards based, but unlike today, the experience we all receive would truly be the same.
Would there then be a war over which one browser is offered in the personal computing service? Perhaps, but I believe there would more likely be competition over the entire computing service itself, much like how cable television providers compete over subscriptions for their service and content today. And by picking a proprietary service, you would indirectly commit to a single centralized web browser as well, which might indeed finally give us what Flash originally attempted to deliver for us in the early dark days of the Web: the same experience for everyone, everywhere.