Search This Blog

Friday, February 11, 2011

Rich Web Apps: RIA, AJAX... - An overview

I've already been several times confronted with the task of explaining what Rich Internet Applications (RIA) are, and why they are different from classical web applications. This is the reason why I wrote this article. It is not meant to be exhaustive and it might contain some approximations but I hope it can help the reader to get an insight and build his own idea.

Web applications typology and RIA

Since advent of the Web era, web sites have evolved by becoming more and more dynamic, then more and more interactive, and more and more complex...

We can schematically distinguish the following successive phases:
  • static web sites (pure HTML)
  • light dynamic web sites (CGI processes on the server side)
  • dynamic pages (JavaScript + DOM + CSS)
  • interactive pages (+ AJAX)
  • rich web applications (RIA...)
« A RIA is a web-based application that is designed to provide functionality similar to a desktop applications. Some RIAs run completely inside a web browser while others are browser-independent. » [1] This definition implies, notably, that just adding a few AJAX interactions to web pages is not sufficient to turn these pages into an RIA. Sometimes authors insist on this difference by distinguishing "thick RIA" from "light RIA". Though, in our understanding, an RIA is always of the "thick" kind and we won't consider "light" RIA as true RIA.

Note that there is a controversy in the literature on the usage of the term RIA. For some, like Gartner, RIA designate only applications running independently from the browser (like Java VM, Flex, or Silverlight). For others, like Kristen Waters, the term RIA also covers applications running inside the browser. In this article we target all cases and, to avoid confusion, we will use the broader expression "rich web applications" (or RWA).

Typical characteristics of rich web applications, compared to traditional web sites, are:
  • richer user experience thanks to more user controls (not limited to basic HTML controls), in-line editing, drag and drop...
  • UI logic running on the client side / session less server side
  • reduced reliance on network/server communications, by transferring only data or partial pages instead of refreshing full page
  • better performances, lower load on the network and on the servers
  • better scalability
  • largely browser and OS independent
  • difficult to index by search engines
Compared to traditional desktop applications:
  • better security, "sandbox" isolation
  • easy distribution, deployment and maintenance
  • application accessible on any host, instantly
  • OS independent
Typical use cases for RWA are:
  • office application (word processor, spreadsheets, presentation tools...) (e.g. Google Docs)
  • personal information and communication (mail, contacts, calendar, tasks, chat, feed aggregation...) (e.g. GMail-GCalendar, Outlook Webmail)
  • cartography (e.g. Google Maps)
  • CRM (E.g.
  • Business Intelligence (E.g.
  • Development tools (E.g. App Inventor)
  • Software-as-a-Service (SaaS) in general


As already said, one can distinguish two kinds of rich web applications. Those based on a framework running in a specific virtual machine (like Java VM, Flex, or Silverlight) on one hand, and those using the browser itself as a virtual machine on the other hand.

Frameworks using the browser as a virtual machine capitalize on the capabilities of HTML, DOM, CSS, and JavaScript. They also usually enable development to be independent from the target browser with seamless degraded mode for old-dated versions.

These are a few well known browser based frameworks:
  • GWT (Google Web Toolkit)
  • Cappuccino
But there are also plenty of vendor specific frameworks, usually little known and used mainly in enterprise environments, like for example General Interface (from TIBCO). Though, most developers available on the market would likely not know these vendor specific frameworks.

Frameworks using a specific virtual machine have the disadvantage of requiring a specific prior install, typical in the form of a browser plug-in. (Though this inconvenient is insignificant in the case of Flex, since the Flash Player is deployed in 96% of internet enabled desktops. For Java the figure is 79% and for Silverlight, 61%. [2]) Advantages are better performances and even richer experience.

Here follows an indicative list of choice factors:
  • Staffing
    • Availability of programming skills
    • Learning curve
    • Documentation and Tutorials, Books
  • Productivity
    • GUI Builder
    • Object Mapping
    • Validation
    • i18n and l10n
    • Industrialisation (automatic builds, tests...)
  • Maintainability
    • Design patterns (MVC, MVP...)
    • Testability
    • Programming language (static typed vs. dynamic typed, e.g. Java vs. JavaScript)
    • Risk (durability of the vendor)


[1] "What is RIA?", by Kristen Waters