End of a plugin

tl;dr For those of you who’ve been living under a rock, Oracle decided to pull the plug on the Java plugin. It’s the end of an era, and it bears investigation.

In the mid-90’s, Sun Microsystems introduced Java, and in so doing, unleashed applets upon the world. Or, to be more specific, unleashed the idea (yet again) that a client-facing tool should be as close to the client as possible.

A side note: We seem to do this a lot. We decide that all the processing should be as centralized as possible, then when we realize the problems with that approach, we start sneaking more and more of the processing—at least the processing that has to deal with the client—back to the client side. Then we start realizing that doing so “splits” the processing load cognitively into several different pieces, and suddenly there’s a flurry of tools designed to centralize all of it into one place again. The applet was just one cycle in this continuous circle of distributed system life; we saw it again with Flash, with Silverlight, and now we’re seeing it again with all these client-side Single Page Application frameworks in JavaScript. And before too long, somebody will come along and suggest that all that code needs to be centralized into one place, and…. oh, right.

In a lot of ways, I mourn the loss of the plug-in. Not because I have a particular fondness for it, or for applets, but because right now the applet represented one of the only other options for doing client-side processing in a browser-based environment after all of the various JavaScript frameworks. Yes, folks, I do believe that there needs to be another option or two for doing such kinds of things, if only because options are better than no options.

But in a lot of ways, this is a perfect example of the Law of Unintended Consequences.

Remember back in the 2000s, when Sun filed suit against Microsoft over its use of Java? One of the immediate effects of that case was to force Microsoft to cease-and-desist in all its use of Java, and of course one of the big places for that was inside Internet Explorer. That meant that for a whole slew of end-users, who were often using applets without even realizing it, suddenly a ton of different websites that used to work just didn’t anymore. And the thing that they very quickly noticed? The big grey empty box that said, “Java needs to be installed”, which to them was the moral equivalent of “Java caused this website to stop working.”

Not a good PR move.

Of course, Sun immediately sought to remedy this problem, and that remedy was the Java Plug-In, which in theory should have “just worked”, but it was never that easy. There were always little niggling complications, with the end result that most users, when faced with the technical complicatins of trying to install this thing, just didn’t.

Particularly when the Plug-In later started spamming people with all these ads. And then later gained the reputation (although I don’t know how much of that was deserved, to be honest) as a huge vector for malware. Not a lot of users are going to keep installing your plug-in when that’s going on.

And that, in turn, led to a significant drop-off in the use of Java on the client. If users couldn’t count on having Java there already, it created a usage requirement on their end that many of them simply chose to walk away from. And if the users couldn’t be counted on to install the thing, then developers couldn’t really count on it being present, which means less desire to actually try to use it, and before too long, it’s just “done”.

Frankly, if you ask me, the Plug-In’s formal retirement is long overdue; it probably should’ve died the moment Oracle acquired Sun.

But the reasons why we got here I think lie entirely in that highly ill-advised move by Sun to ask the DOJ to remove Java from Microsoft’s products—at the time, I said that Sun actually should’ve requested the DOJ to force Microsoft to include Java on every single installation of Windows ever made. That would’ve ensured that Java was already present, installed, and ready to go, and the need for the PlugIn (and with it the end-user complications and ugly reptuation) would never have emerged.

What’s more, if Java is already installed on the client, it would’ve removed the major obstacle towards using Java as a desktop application development option, too, since now users wouldn’t have to install Java as part of obtaining the application install bundle. (Sun always had some pretty severe restrictions around redistributing the JVM, which I thought highly stupid for a company that kept trying to tout Java as a client-side solution.) If you’ve already got Java installed on the end-user’s machine, then running a Java Swing application is absolutely trivial; without that, it’s a major pain in the ass.

But Sun wanted to “punish” Microsoft, and prove that they were right, and Microsoft was wrong. So Java came out of Windows, Microsoft put .NET in its place, and today we talk about .NET desktop applications among those who are still interested in doing desktop applications. If only Sun had managed to think a little more strategically, they could’ve completely inverted that story.

And maybe Java-on-the-client would still be a story today.

RIP, Java Plug-In. I’ll miss you like I’ll miss Internet Explorer.

Not very much.