It's essential for IT managers to consider and be aware that more than one delivery platform exists today for Rich Internet Applications. Table 1 covers three platforms and their associated technologies.

While the last two approaches still involve the browser as their foundation, each also taps into powerful virtual machines that are installed as plug-ins to deliver even richer applications.

Let's look at the choices.

JavaServer Faces
Let's start with JavaServer Faces. JSF is an open source, component-based user interface Java framework for building pure browser-based applications. JSF is also the standard technology for building Web user interfaces in the Java EE 5 stack. Pure browser-based applications mean that nothing beyond the standard browser is required to run the application. JSF components generate standard HTML markup. JSF provides a declarative approach to designing the UI. JSF components provide all the logic, as well as encapsulated HTML rendering, so the developer can concentrate on building the UI, instead of messing with low-level HTML. Out-of-the-box, JSF provides a basic set of components such as links, buttons, layout, and tables. What's more, the JSF component approach makes it the perfect technology to develop Rich Internet Applications. However, to efficiently deliver a Rich Internet Application, we have to take the component model a step further.

A popular technique for delivering RIA applications inside a Web browser is AJAX. AJAX stands for Asynchronous JavaScript and XML. It is basically a collection of existing technologies for radically changing user experience on the Web. However, manual AJAX development or the utilization of one of the JavaScript libraries is challenging and, ultimately, both are very poor options. With manual development, it's not uncommon to spend a significant amount of time battling JavaScript browser incompatibilities. Finally, and probably most importantly, manual AJAX coding doesn't fit the JSF component model.

: Nevertheless, all is not hopeless. Due to JSFs extensibility and its component approach, combining JSF and AJAX can be done easily. That's where RichFaces comes in. RichFaces is a rich JSF component library that provides a large number of components with AJAX support. Rich components from RichFaces render all the necessary JavaScript to send an AJAX request and, at the same time, know how to partially update a part of a page when a response comes back. IT organizations can add rich functionality without writing any JavaScript code. Developers can again concentrate on UI development instead of low-level AJAX coding and JavaScript debugging (because the components' JavaScript code will have been tested in all the modern browsers).

While JSF and RichFaces are solid tools for building Rich Internet Applications, other alternatives do exist. Enterprise IT managers must understand and be aware that other delivery mediums exist for Rich Internet Applications. First, we have more than just the browser to deliver Rich Internet Applications. It's common today to look at the browser as the only vehicle for delivering Rich Internet Applications, but it isn't the only medium that should be considered.

Let's look at a quick example using JSF and RichFaces components. We are declaratively defining the UI using JSF tags. Declaratively defining the UI is easier and more natural. When this page is processed, UI components on the page will render the necessary HTML and JavaScript to be sent to the browser.

    <h:form>
   <rich:panel>
  <f:facet name="header">RichFaces</f:facet>
  <h:panelGrid>
    <a4j:commandButton value="Hit Me!" actionListener="#{clickBean.count}" reRender="c" />
    <h:outputText id="c" value="Number of hits: #{clickBean.numOfClicks}"/>
    </h:panelGrid>
    </rich:panel>
    </h:form>

The model behind this page is a simple POJO:

public class ClickBean {

     private Integer numOfClicks = 0;

     public Integer getNumOfClicks() {
     return numOfClicks;
     }
     public void setNumOfClicks(Integer numOfClicks) {
     this.numOfClicks = numOfClicks;
     }
     public void count(ActionEvent event) {
     numOfClicks++;
     }
}

And, finally, when the page is run in a Web browser, Figure 1 shows the result.

Note that when clicking the button, only the counter area is updated. We are not reloading the full page.