1.2. The Rise of the Cool: Rich Internet Applications

The point we find ourselves at now is that we're developing rather complex web apps these days—so complex, in fact, that we probably need a new name for them. If nothing else, we all know that the IT industry loves to invent new terms for things!

We're trying to recapture some of what we lost when we moved to the Web: the power of the native application. Take a look at Figure 1-3, where you can see a fairly typical native application.^[]

^[] Note that I'm not holding this up as an example of a great native application! This is an old application I had written at work over ten years ago now. It's not stunningly beautiful or anything like that, but it makes the point well enough.

These so-called native applications are applications coded for a specific operating system and that run more or less entirely locally on an individual workstation. These types of applications have the benefit of access to the full power of the underlying operating system and the hardware of the computer, so they tend to look better and, most importantly, are more functional and full-featured. Things you take for granted in such an environment (such as local disk storage; multimedia capabilities—video/audio playback, for example; access to I/O devices like disk drives, mice, and printers; more advanced UI metaphors like grids, trees, and drag and drop) all are harder to come by in the web environment than they are in native applications. There is a richer set of user interface (UI) components, sometimes called widgets, from which to build the application: grids that can do all sorts of sorting and splitting and other advanced features; tree lists that can organize data and allow the user to expand and contract groupings as they see fit; toolbars with all kinds of button features; menus and spinners and tabs and fancy check boxes and sliders and so on and so forth! All of these are things available in virtually any graphical user interface (GUI) environment like Windows or Mac OS. On the Web, however, much of that sort of interface richness is harder to come by.

Figure 1.3. An example of a "rich-client" application

That's where the RIAs come in. An RIA isn't a single specific thing; it's more of a paradigm, almost an approach to web app development. RIAs are characterized by appearing in many ways to look, feel, and function just like those native applications we left behind.^[] We develop them using more advanced techniques, a much heavier dependency on the clients' capabilities, and with an eye toward building a much more powerful application for the end user. In Figure 1-4 you can see an example of such an application.

^[] To be clear, native applications are of course still in use today and are still being developed anew. However, it's probably fair to say that more development effort these days goes into web-based applications, so in that sense we've "left native applications" behind, for the most part anyway.

Figure 1.4. An example of an RIA

Let's compare and contrast the previous four screenshots, primarily comparing each to the native application example on the basis that it is the ideal we're striving for.

First, the web site, while hopefully (since it's mine!) fairly pleasing visually, doesn't really look like any of the applications, least of all the native application example. The photo-sharing web app looks more like the native application in the sense that it's clear you are supposed to perform some functions with it rather than just more passively obtain information from it, but it still doesn't look a whole lot like the native application; it looks like a hybrid, somewhere between the web site and the native application.

Now, comparing the RIA to the native application, the RIA looks a lot more like the native application. It has menus, toolbars, trees, grids, and just generally looks more robust. It's clear that its focus is in giving the user the ability to manipulate data, files, and directories in this case. It's clearly more focused on the idea of doing something than the web site example was.

RIAs, and perhaps more precisely the idea of bringing native applications to the Web, is where we are today, although interestingly we're also taking some of the "coolness" the Web brought about—things like multimedia, animations, and effects—and rolling them into our applications. We've evolved beyond simply bringing native application-like capabilities to the Web; we're now trying to evolve that concept to make applications that are actually cool! This combination of native application-like functionality and web coolness are what modern RIA development is all about (and what Ext JS is all about too!).