17-10-2012, 03:57 PM
Rich Internet Application
Rich Internet Application.pdf (Size: 119.66 KB / Downloads: 34)
Rich Internet Application
Rich Internet applications (RIAs) are web applications that have the features and functionality of traditional desktop
applications. RIAs typically transfer the processing necessary for the user interface to the web client but keep the bulk of
the data (i.e., maintaining the state of the program, the data, etc.) back on the application server.
RIAs typically do the following:
• Run in a web browser, or do not require software installation.
• Run locally in a secure environment called a sandbox.
History
The term "Rich Internet Application" was introduced in a white paper of March 2002 by Macromedia (now Adobe), though
the concept had existed for a number of years earlier under names such as:
• Remote Scripting, by Microsoft, circa 1998
• X Internet, by Forrester Research in October 2000
• Rich (web) clients
• Rich web application
Traditional web applications centered all activity around client-server architecture with a thin client. Under this system all
processing is done on the server, and the client is only used to display static (in this case HTML) content. The biggest
drawback with this system is that all interaction with the application must pass through the server, which requires data to
be sent to the server, the server to respond, and the page to be reloaded on the client with the response. By using a
client side technology which can execute instructions on the client's computer, RIAs can circumvent this slow and
synchronous loop for many user interactions. This difference is somewhat analogous to the difference between "terminal
and mainframe" and Client-server/Fat client approaches.
Internet standards have evolved slowly and continually over time to accommodate these techniques, so it is hard to draw
a strict line between what constitutes a RIA and what does not. But all RIAs share one characteristic: they introduce an
intermediate layer of code, often called a client engine, between the user and the server. This client engine is usually
downloaded as part of the instantiation of the application, and may be supplemented by further code downloads as use of
the application progresses. The client engine acts as an extension of the browser, and usually takes over responsibility for
rendering the application's user interface and for server communication.
What can be done in a RIA may be limited by the capabilities of the system used on the client. But in general, the client
engine is programmed to perform application functions that its designer believes will enhance some aspect of the user
interface, or improve its responsiveness when handling certain user interactions, compared to a standard Web browser
implementation. Also, while simply adding a client engine does not force an application to depart from the normal
synchronous pattern of interactions between browser and server, in most RIAs the client engine performs additional
asynchronous communications with servers.
Today’s client/server architecture is different from that of a years back, some of those differences are:
• Client applications are no longer accessing databases directly. Instead they access data services embodied in the
ethos of Web 2.0.
• Client/server applications do not run directly on the operating systems, but on an intermediary platform called a
runtime. This makes portability easier -- a lesson learned in large part from Java.
• With broadband, it’s no longer an issue to download an application that is a couple of MB or more. Distribution
technologies even allow in-place updates of software right at the client machines, so distribution has become less of
an issue than it was 10 years ago.
Rich Internet Application
Page 2 of 9
Logistica Solutions Inc., 1251 N Jefferson St, Anaheim, Ca 92807, USA, (714) 238‐3209
Benefits
Although developing applications to run in a web browser is a much more limiting, difficult, and intricate process than
developing a regular desktop application, the efforts are often justified because:
• installation footprint is smaller -- overhead for updating and distributing the application is trivial, or significantly
reduced compared to a desktop or OS native application
• updates/upgrades to new versions can be automatic or transparent to the end user.
• users can use the application from any computer with an internet connection.
• many tools exist to allow off-line use of applications, such as Adobe AIR, Google Gears, and other technologies
• most RIA techologies allow the user experience to be consistent, regardless of what operating system the client.
• web-based applications are generally less prone to viral infection than running an actual executable
Because RIAs employ a client engine to interact with the user, they are:
• Richer. They can offer user-interface behaviors not obtainable using only the HTML widgets available to standard
browser-based Web applications. This richer functionality may include anything that can be implemented in the
technology being used on the client side, including drag and drop, using a slider to change data, calculations
performed only by the client and which do not need to be sent back to the server, for example, a mortgage
calculator.
• More responsive. The interface behaviors are typically much more responsive than those of a standard Web browser
that must always interact with a remote server.
The most sophisticated examples of RIAs exhibit a look and feel approaching that of a desktop environment. Using a client
engine can also produce other performance benefits:
• Client/Server balance. The demand for client and server computing resources is better balanced, so that the Web
server need not be the workhorse that it is with a traditional Web application. This frees server resources, allowing
the same server hardware to handle more client sessions concurrently.
• Asynchronous communication. The client engine can interact with the server without waiting for the user to
perform an interface action such as clicking on a button or link. This allows the user to view and interact with the
page asynchronously from the client engine's communication with the server. This option allows RIA designers to
move data between the client and the server without making the user wait. Perhaps the most common application
of this is pre-fetching data, in which an application anticipates a future need for certain data and downloads it to the
client before the user requests it, thereby speeding up a subsequent response. Google Maps uses this technique to
load adjacent map segments to the client before the user scrolls them into view.