The idea of having a rich internet application is nothing new, but the RIA paradigm has new implications in the world of web 2.0, and fierce competition between companies and their frameworks.
RIA’s use of “sandboxes,” or offloading the computing burden to the client, is a key feature that really helps take the burden off the server. This new architecture lets the developer make calculations and process data on the client-side when usually the server would have to perform such utility functions. This not only increases performance for the user, but also frees up server performance for more bulky procedures. As you can imagine it also frees up a lot of network traffic.
Since the top three frameworks (Adobe Flash/FLEX, Silverlight and Java FX/Apache Pivot/Applets) have similar distribution methods (where the entire app is downloaded to the client browser and run locally with back-end connections to the server), once the initial download is complete the app runs almost as seamless as a desktop application. Updates become an easy effort because the app is distributed as a whole, making updates as simple as publishing a new app. And, the next time the user logs-in it will download the new application. The sandbox that it runs in can keep local properties while the UI is updated.
With the expanding breadth of the internet and most people getting broadband internet access, it has paved the way for more download-centric apps, whereas on a modem this was not possible several years ago. Even java applets back in 1995 had a low adoption rate because it took too long when a user was used to getting instant gratification from a simple HTML page. Once downloaded, these apps that reside in the browser can still be used when the user goes offline. Adobe flex has built-in offline syncing that enables a user to go offline while the app keeps track of user operations. When the user goes back online, it syncs back with the server—without any effort from the user. These kinds of API features make RIA applications that much closer to becoming as fast and as efficient as thick desktop apps.
While java claims it is, “write once run anywhere”, RIA gives us the promise of “write once, look the same for everyone”. This has huge implications for the user experience. No more guessing what an app will look like for a certain OS and browser, or what might happen in a certain resolution. These things are now within the developer’s control and can be done without several sets of code to account for the various possibilities. One set of code, done right, the first time.
Security becomes a lot tighter with all operations performing inside the application. The only real vulnerability is the server requests. The use of “sandboxes” help the applications complete local calculations and data manipulations, as well as business logic, in a secure application-only scope. The downside is, due to browser security, most if all of the frameworks deny access to the underlining file system, and the operating system as well.
RIA applications rely heavily on web services (SOAP or XML over HTTP) for their data. While this is a good fit for most requests, some developers are left in the dark with their legacy code that does not easily support this approach. As of late, there have been several new offerings from Adobe and other companies where you can take current legacy code and expose their methods as remoting and messaging endpoints. An example would be: BlazeDS[1] for java code, where any java API can easily be set up to connect to an Adobe FLEX front-end with almost no coding to connect the two.
Adobe Flex:
http://www.adobe.com/products/flex/
Apache Pivot:
Microsoft Silverlight:
http://www.microsoft.com/design/toolbox/
[1] http://opensource.adobe.com/wiki/display/blazeds/BlazeDS/
Author: Jon Borgman, SDS Consultant and RIA Technical Specialist