Voleris Rich Internet Application Blog

Believe it or not, the title of this post, “The Return of Java for RIAs”, is becoming less bold a prediction as each day passes. This is a Good Thing.

Let me begin by explaining why the prediction was bold. My first exposure to Java was applets. The idea seemed brilliant to me at the time — a full powered rich application embedded in a web page (I don’t recall “rich” being a buzzword then). Surely this would revolutionize web-based applications.

[Fast forward a decade or so]

What the heck happened? What happened was, frankly, Java applets suck. I think there are two primary reasons for this:

1. To this day, loading the JRE is too slow. This is not such a big problem for a large application. (Check out ThinkFree for a great example of the power of Java in the browser.) However, the web needs the ability to have small, nimble applets, and we’re just not there yet. Note that the JRE download size is NOT the issue.
2. There were so many bad applets. By “bad” I mean ugly, misused, poor design, etc. Granted, you could say the same thing about the web in general. 90% of web sites are still bad to this day. However, nothing is worse than waiting in suspense (see #1) to be let down, or worse yet appalled.

Now I have to figure out how to convince you that Java applets are the wave of the RIA future. Oh my.

The idea of Java in the browser is still a good one. In fact, it’s downright seductive. We just need to work on some of the issues that have plagued applets.

Fortunately, there’s been more talk of Sun making some kind of browser edition of Java that will enable quick loading. This would be great. On a side note, I think it would also be nice if browsers would give users the option of automatically loading Java in the background once the browser is fully initialized.

Also, there seems to be a new wave of Java applets and desktop applications being born. It almost seems as if a second generation of Java developers has come of age and is intent on building better rich applications. This is really great because the technologies are improving, and we need to see good application design to put the technology to use in a good way.

Last but not least, Java is truly an open platform now. The Java language plus all the accompanying facilities are completely controlled by the Java Community Process. The only remaining issue was that Sun’s Java virtual machine implementations were closed source. As of a couple of months ago, this issue has been solved by the open sourcing of the VM’s by Sun and the GPL license Sun chose for Java. This is huge, and in my opinion, solidifies Java as an open standard, much like HTML and JavaScript (ECMAScript) are. The language is Free, the platform is Free, and many of the great tools are Free (as in beer and liberty).

Java may be poised to give Adobe’s Flash/Flex (closed, proprietary, non-Free) a run for its money.

It seems that each day brings a new way to build RIAs. I won’t dive into the list here, but suffice it to say that choosing a platform for an RIA application is becoming an increasingly complex task. But that’s a post for another day. The point is that while there are a large number of options, they all seem to be driving towards a common goal: to look like a desktop application.

What’s so bad about that? I’m glad you asked. But before I get to the bad, let’s look at what’s good about mimicking desktop applications. The most obvious benefit is familiarity. People generally know how to operate hierarchical menus, tree controls, context menus, etc. Naturally, it makes sense to include the familiar desktop metaphors in RIAs where appropriate, and even make the RIA look and feel as much like a desktop application as possible. Right?

Well, I disagree. Breaking away from the desktop is a great opportunity to break away from the desktop application paradigms. Reinventing the desktop of the past decades for the web is a mistake. Sure, the “desktop interface” was evolutionary, but it was just a step in the process, and is certainly not the gold standard after which future paradigms should be modeled.

Yet we go to amazing ends to make the web look like the desktop. And sadly, the web is beginning to fall in line. And here’s why:

• Ignorance. If you don’t know of a better way, you’ll probably stick with the same.
• Risk. New is different (arguably). Different is risky.
• Budget. Treading new ground often means more testing, which takes more time and money.

As pioneers do what they do and progress is made, mistakes will also be made. Take Google. Gmail presented a simple and natural interface, yet was more powerful and flexible than any other email client. OTOH, Google’s first shot at a news reader fell well short of being usable and competitive with other readers. They’ve since learned their lesson and improved the Reader. Was it Guy Kawasaki who said (paraphrasing), “If you weren’t embarrassed of version one, you were too late?”

It will take creativity, imagination and conscious effort to improve the interfaces of tomorrow’s RIAs. I only hope that the framework and library vendors (on whom us mere mortals rely) “get” this and provide some sorely needed leadership in this area.