Accessibility

Flex Article

 

Improving RPC performance in Flex RIAs


Table of Contents

  1. Introduction
  2. RIA performance vs. traditional web app performance
  3. Capturing client-server performance
  4. Large request sizes
  5. Large response sizes
  6. Frequent network calls
  7. Badly timed requests
  8. Conclusion
Comments

RIA performance vs. traditional web app performance

The advent of RIAs and the removal of the "page" paradigm enables more interactive, responsive, and generally richer user experiences. It can also, however, introduce an entirely new set of potential performance problems. Rather than a simple request-response model where each page or view in a web application has a single HTTP request and a single HTTP response, a view in an RIA may be a collection of self-contained components, each retrieving their associated data at different times, and from potentially different sources.

Consider an administrative application that, for a selected customer, displays their order history, personal information, and contact details (see Figure 1).

Sample application

Figure 1. Sample application

The manner in which this information is represented, requested, and returned for this type of application differs for a traditional web application and an RIA. Table 1 below summarizes these differences.

 

Traditional web app

RIA

Request

A web application makes a single HTTP request for this view. The request may contain the customer information, or it may be stored in a server-side session. The server logic may in turn make multiple requests on the back-end database to build up a response.

An RIA view is generally developed as a collection of self-contained components. An RIA doesn't request a "page"; each component requests the data it needs. An RIA application for the example is likely make several requests rather than one.

Response

The web application response contains the HTML necessary to render the entire page. All formatting is performed on the server and is contained within the response.

Each request made by an RIA returns a data structure that the client renders.

Representation

The client code (the HTML and any browser scripting) generally doesn't concern itself with any underlying data structures. The browser merely renders the HTML it has been provided with.

The client code must be aware of each underlying data structure. The formatting logic is in the client.

Table 1. Differences between traditional web apps and RIAs

For these reasons, RIA developers need to think carefully about the frequency, size, and timing of calls from the client to the server.

Page 2 of 8
Previous Page
Next Page