Beyond enterprise portals

Mashups are a really cool way for Web developers and even Web users to build interesting and useful composite applications. But isn’t that what portals do already? After all, enterprise portals have been delivering integrated applications called portlets or pluggable application components for the past few years.

Portlets
Portlets are variations on servlets, which are back-end applications designed to deliver different types of services on the Web. A portlet is typically based on the Java Portlet Specification JSR16B, which defines how portal software makers can integrate different "common services" from the enterprise—the Internet, intranet or extranet—in a standardized fashion. Portlets can be plugged together to build mashed up applications in a single portal interface.

Unfortunately, portlets don’t get you anywhere as far along as the Google and Yahoo technologies because all the application integration for portlets takes place at the mid-tier or back office. Yes, you can pull together heterogeneous, unrelated portlets and plug them together, but they are typically not going to share information unless somebody ties them together via the portal framework. In fact, even mashups don’t fully allow the kind of tight integration we expect of desktop integration, although Yahoo Pipes and a number of other AJAX-based toolkits from companies such as JackBe, Backbase and OpenLaszlo do allow more integration on the client side than portlets provide.

Google and Yahoo are providing tools that allow developers to integrate in the browser, not in the middle tier or back end. Unfortunately, the AJAX-based tools provided by Google, Yahoo and other AJAX vendors only get you part of the way there. They don’t really provide a full solution to deliver completely stateful (i.e. aware of what state they are in at any time without some sort of network connection) applications. That is where technologies such as Flex/AIR, Silverlight, JavaFX and XUL are really helping to change the world. Those technologies allow developers to build completely stateful applications that are every bit as rich and functional as desktop applications found in Windows, MacOS, and Unix/Linux KDE/ Gnome X/Windows graphical user interface systems.

Web browser vs. desktop applications

Is anyone surprised when they open up MS-Excel, highlight a row or column of data, select a graphing tool and produce a pie or candle chart, or sort the data or bring that data seamlessly into Word to embed it in a composite document? Probably not. We have high expectations for Windows desktop applications, so it doesn’t surprise us when they do some pretty useful, cool things like object linking and embedding (OLE) or dynamic data exchange (DDE). We expect that and more because we have high expectations for desktop Windows applications.

Is anybody surprised when they open up a Web browser, highlight a row or column of data, select a graphing tool and produce a pie or candle chart, or sort the data or bring that data seamlessly into another Web application to create a composite document? You bet they are, because most people have low expectations for Web applications, and they have no idea that RIAs can deliver desktop application quality and functionality.

Technology provided by Flex/AIR (and eventually Silverlight, JavaFX and others) will allow developers to build desktop quality applications for the enterprise Web, without the need for a portal framework. If it’s now possible to use a SOC to deliver tightly integrated desktop quality applications that can make use of whatever services I have on the network, then what do I need an enterprise portal for? As I said earlier, the portal becomes a data and application silo that restricts access to services and data, rather than allowing the smart Web client to pick and choose whichever service is required for the task at hand.

Loosely coupled components
About 10 years ago, just as the Web was starting to explode, SUN introduced the concept of the Java Applet. Applets were seen as the next wave in adding intelligent plug-ins to the Web browser using the browser’s JVM. About that time, Lotus Development (now part of IBM) introduced the concept of the Infobus.

The Infobus was an event-based network between applets that would allow information to be seamlessly shared between a suite of related applets. It was introduced as part of a Lotus technology called E-Suite, now defunct, which was a set of applets based on the Lotus Smart Suite desktop application software. Smart Suite was the number one competitor to MS Office for many years, but was ultimately crushed by Microsoft. E-Suite was an attempt to take the basic functions of spreadsheet, word processor, presentation graphics and graphics editing and make them available as Java Applets.

Those applications worked together flawlessly and when the E-Suite word processor had data to be shared with the spreadsheet or presentation graphics applets, they all knew about it and could make use of that data in a dynamic fashion. MS-Windows applications have long had that capability, which is called dynamic data exchange and object linking and embedding. Imagine that capability available to your Web applications in the browser.

With Web application development technologies like Flex and AIR, those capabilities are available to developers out of the box. The approach is called event-based programming, and it allows unrelated components to be aware of the state and availability of data of other components running in the browser or Flash Player.

Event-based programming allows loose coupling of applications and data so that it becomes easy to plug unrelated application components or modules together in new and meaningful ways. That allows the creation of dynamic mashups that integrate together and provide seamless inter-application data sharing between heterogeneous components.

You be the judge

Now that you know the facts about emerging RIA technology, you can judge for yourself whether your business portals are serving the business needs of the enterprise and your budget appropriately. Nobody realistically expects business and government to throw out their investment in portal products. But adding RIA capabilities to portals can significantly enhance a portal’s capabilities, reduce the number of different portals that get implemented and their complexity, and can provide important new features and functions to the thin client for the user. Don’t you think it’s about time users had the same high expectations about thin-client applications as they do about desktop applications?