You are hereInkriti Ideas / AJAX / White Paper - AJAX vs. Flex - A comparison

White Paper - AJAX vs. Flex - A comparison

Executive Summary

In the rapidly enhancing technological scenarios for building Rich Internet Applications (RIAs), it has become difficult to select the right technology that meets all the industry requirements such as user interaction, look and feel, performance, development, maintenance, security, cross browser compatibility, cross-platform compatibility and integration with an existing enterprise, legacy applications.

This article is a comparative insight of competing RIA technologies such as Flex and AJAX based frameworks. The article is divided into three categories that you should consider when you compare the RIA technologies - Flex and AJAX. These are:

For Developers - download, tools, deployment strategies etc
For IT Executives - availability and ease of training developers, support, maintenance etc
For Business User - UI components etc

Checklist

Please take the small survey below and we will suggest what will work best for you. We have vast expertise in developing enterprise applications using RIA technologies. We will present you with possible scenarios of developing RIAs based on your answers in the survey.

Does your application have lot of UI screens and user interactions?
Does your application need partial screen updates (real time data) or asynchronous communication?
Are you comfortable with the look/feel provided by a HTML application or would you rather go with a richer user interface?
Is bandwidth usage a consideration when the application is deployed?
Is it required for your application to be cross-browser compatible without any additional client side downloads (plug-in)?
Do you feel your application will be accessed from multiple OS and browsers?
Is the client layer of your application architecture fat?

Technology Suggestion

If you answered all “No” above, it will be a safe bet to go with a regular application that is devoid of RIA features. It seems that a lot of features that generally constitute an RIA are not present in your application.

We would still suggest going with a RIA as the applications become rich in terms of user interface and interaction. Rich Internet applications (RIA) 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 generally are richer in terms of UI components and user interaction, more responsive, handle real time data well and have better network utilization.

If your answer to any of the questions above is “yes”, you should go with a RIA for the application that you have in mind. Rich Internet applications (RIA) are Web applications that have the features and functionality of traditional desktop applications.

Your answers suggest that RIA will be an ideal solution to go with. For more information about RIAs, please visit the RIA section of our site.

Survey Continued...

Please proceed with the next set of questions below and we will suggest what RIA technology will work best for you - whether you should go with Flex or AJAX as the RIA technology.

Are reliability, availability, scalability and performance big enough considerations for the application?
How does the UI components compare to standard sets like those of HTML?
Is security of you application a high consideration?
Do you foresee a lot of maintenance requirements for the application - like new feature addition or changes to exiting logic?
Are in-house developers more comfortable with web technologies (XHTML, CSS, DOM, ECMAScript etc) or with enterprise technologies (like Java, .NET, PHP etc)?
Do you plan to hire developers for building the new application?
Do you consider commercial support, online resources, maturity of user community and forums important for the technology on which the application will be build?
Will your application have lot of cross domain interactions - your application talking to another domain to get data?
Is the programming model distributed?
Are you comfortable with vendor lock-in or going with proprietary softwares/plugins?
Is your application logic intensive?
Do you have application servers in your current deployment or just web servers are enough to deploy the application?
Do you foresee any migration of your application from one server to another sometime in future?

Technology Suggestion

If you answered mostly “Yes” in the above set of questions, Adobe Flex technology will be the ideal technology to build your RIA. This technology is cross-platform and quite powerful to create application UI. Adobe Flex provides the option to create Flash user interface by compiling MXML, a XML based interface description language.

Flex comes with various components and features that make capabilities such as web services, remote objects, drag and drop, sortable columns, charting/graphing, built in animation effects, and other interface interactions simple. Since the client only loads once, application workflow is significantly improved versus HTML based applications (eg. PHP, ASP, JSP, CFMX) which require executing templates on the server with every action. Flex's language and file structure are seeking to decouple application logic from design.

Flex is an enterprise level technology and as such has much higher levels of security and scalability built in - when compared to other RIA technologies. Please refer to the Flex section of our site for more details on this topic.

If you answered mostly “No” in the above set of questions, AJAX will be an ideal technology to build your RIA. AJAX (shorthand for 'Asynchronous JavaScript and XML') is a development technique for creating interactive web applications. The intent is to make web pages feel more responsive by exchanging small amounts of data with the server behind the scenes, so that the entire web page does not have to be reloaded each time the user requests a change. This is intended to increase the web page's interactivity, speed, functionality, and usability.

We have published an exhaustive study of AJAX and its related issues. Please refer to the AJAX section of our site for more details.

For Developers

This section covers topics that are relevant to developers in choosing between Flex and AJAX. It provides an insight into the following areas:

It covers areas such as browser compatibility, the servers needed to deploy these applications, the necessary frameworks available, security issues, scalability of applications, cross-domain and serverless deployments.

Downloads

For developers to get started with either Flex or an AJAX based framework, the following resources will prove quite helpful.

Flex

There are a lot of resources available online that walks a developer through downloading and installing Flex. Some of these are:

Installing Flex is very simple and fairly out-of-the-box. The installation steps are self-explanatory.

AJAX is an amalgamation of web technologies(XHTML,ECMA Script,CSS,). It doesn't require anything to install in order to run AJAX based application. If AJAX applications are developed on top of third party frameworks, it is required to install the services provided by the third party vendor. The relevant resources to work with an enterprise level AJAX framework - Backbase - is presented below.

Backbase

It currently ships three versions of its AJAX framework - Struts, JSF and Client Editions. It also provides a community edition.

Tools and IDEs

Tools and IDEs are important from developer's point of view as they ease the development process a lot. The Tools provide visual aid to development as well as helping debug the applications from inside these IDEs.

Flex

Adobe® Flex™ Builder™ 2 is an Eclipse™ based IDE for developing rich Internet applications (RIAs) with the Adobe Flex framework. Using Flex Builder 2, developers can quickly build and deploy applications that are expressive, intuitive, and rich in interactivity. Flex Builder 2 is a productive development environment that makes it easy for developers to customize their applications to match the desired look and feel.

Adobe Flex Builder™ 2 software combines the power of a code-centric IDE with the productivity of a visual user interface. In addition, integrated debugging lets developers quickly track down and eliminate problems so they deliver higher quality applications.

AJAX

AJAX alone has no specific IDE and we can use general web development tools which supports XHTML, ECMA script, CSS etc. Different AJAX frameworks sometime provide IDEs to aid development of applications using AJAX.

If we take the case of Backbase, it's AJAX developer tools run within the browser (debugging) and has plug-ins for Eclipse and Dreamweaver which provide code completion & syntax highlighting. It supports development in leading IDEs

Eclipse 3.0+
Microsoft Visual Studio 2003 & 2005
Macromedia DreamWeaver MX2004 & 8

Deployment Strategies

Deployment strategies are quite relevant when thinking of deploying applications built using Flex or AJAX, especially when applications are of enterprise level or built on top of big legacy systems. This section covers topics like:

Browser Compatibility

For any web based application, browser compatibility is one of the biggest considerations when choosing technologies.

Flex based Applications

Flex application runs in an AVM of flash player which is a browser plugin. Any browser which has a flash player plugin will support the Flex and render in the same way.

Flash Player is the high-performance lightweight, highly expressive client runtime that delivers powerful and consistent user experiences across major operating systems, browsers, mobile phones, and devices.

AJAX based Applications

JavaScript implementations are not standardized across browsers and operating systems. This means that programs must be aware of the browser, the operating system, and their respective versions. Programs must execute different code depending on specific combinations thereof, which is a developer’s nightmare. The most essential characteristic of a JavaScript/AJAX product is, therefore, how well it handles these combinations and shields the developer from the complexity of managing them in application code.

As such, pure AJAX application does require no plug-ins. We can develop AJAX applications using JSON, JavaScript, VBScript and so on. Due to various scripts and versions of these scripting languages, applications become incompatible across the browsers.

In order to meet the needs of industry, generating a healthy competitive landscape based on differentiation of products and services, rather than technology models, generating confidence among vendors and users of new technology ECMA has taken initiation to bring all the scripting languages under one umbrella.

ECMA International facilitates the timely creation of a wide range of global Information and Communications Technology (ICT) and Consumer Electronics (CE) standards, for: Scripting and Programming Languages and many more.

Application developed using the scripting languages which follows ECMA standards have cross-browser compatibility.

Servers

Flex

Flex was initially released as a J2EE application or JSP tag library that compiles MXML and ActionScript on-the-fly into Flash applications (binary SWF files). Later versions of Flex support the creation of static files that are compiled at authoring time and can be deployed online without the need for a server license. In effect, any J2EE compliant application servers will support Flex.

The Flex module for Apache and Microsoft IIS provides web-tier compilation of MXML and ActionScript files on Apache and IIS web servers. This module lets you rapidly compile, test and deploy an application by simply requesting the main application file from a web browser, similar to working with server-side scripting languages such as PHP, ColdFusion or JSP.

You do not need a J2EE application server to use the web-tier compiler. The Flex module for Apache and IIS works with just the web server and a Java runtime environment (JRE).

(Source:-Adobe)

The precompiled Flex application can be ported on any server but it will lose the features like server side security and data services that come with the Flex server. It will then be more dependent on the server where the precompiled Flex application is deployed.

AJAX

Frameworks

One of the biggest considerations when designing an application is the availability of frameworks that can ease development and make the application scalable. In software development, the term framework is one of the most overloaded and overused terms within and between development teams. When developers write large pieces of code that they consider significant enough to consider leveraging on other projects, they tend to supplement the code with this term. Thus there are many types of frameworks: persistence frameworks, transaction frameworks, logging frameworks, aspect-oriented frameworks, animation frameworks, unit-testing frameworks, and the like.

The section is further divided into the frameworks available for Flex as well as for AJAX.

Flex Frameworks

Cairngorm is an architectural framework that provides a suggested implementation of a technical architecture upon which you can build your own, more complex, application-specific architectures. Cairngorm is a microarchitecture that addresses three key areas:

Handling user gestures on the client
Encapsulating business logic and server interactions
Managing state on the client and representing this state to the user interface

Cairngorm offers a microarchitecture (collection of design patterns) that aids us in consistently solving recurring design challenges.

(Source: Adobe)

Below is a block diagram that explains the Cairngorm Architecture:

All the user interactions in RIA - like button click, clicking on Link - will broadcast that event to RIA Front Controller written in ActionScript, using the ViewHelper.

The FrontController then decides which Command class to call based on the event broadcasted by, say, button click in RIA.
There will be separate Command class for each use-case as mentioned in the section above. The command class also acts as a responder. (For example, LoginCommand will implement both Command as well as Responder interfaces. Responder interface will have two methods - onResult and onFault).
The Command class then calls the Business Delegate class associated with that use-case.
Business Delegate class then looks up ServiceLocator for the HTTPService call
ServiceLocator acts as an abstraction of Service Implementation. The HTTPService call is registered with the ServiceLocator
BusinessDelegate then calls the HTTPService it got from ServiceLocator with the requestParams that use-case needs.
Once the HTTPService call returns, onResult method of Command class gets called. This method takes the resultParams out and sets those in RIA (-text fields, show error messages).

Another good resource to learn about cairngorm framework is available at Cairngormdocs.org.

Source: caingorm

AJAX Frameworks

Backbase offers a comprehensive AJAX Development Framework for building Rich Internet Applications that create a superior end-user experience and have the same richness and productivity as desktop applications. The Backbase AJAX Client Edition contains a client-side JavaScript engine which integrates with any server-side environment. It can be used for regular web applications or embedded in software or hardware products.

The Backbase AJAX Client Edition consists of a client-side JavaScript library, AJAX Widgets, server-side code samples for PHP, Java and .NET and developer tools.

Source : Backbase

The Backbase AJAX Engine is a robust and comprehensive JavaScript-based application that provides one of the most advanced client-side runtimes for developing AJAX applications. It provides a large amount of generic and reusable functionality, such as drag-and-drop, animations, back-forward button support, bookmarks, focus model, state management, data binding and templating.

The Backbase AJAX Widgets are pre-built and accelerate application development. Over 50 customizable Widgets are included, and developers can also create their own Widgets.

The Backbase AJAX Developer Tools extend popular IDEs and offer debugging tools within the web browser itself.

Security

Security of Flex Applications

The Flex security model protects both the client and the server.

Client Side

Flash Player runs inside a security sandbox that prevents the client from being hijacked by malicious application code. This sandbox prevents a user from running a Flex application that can access system files and perform other tasks. Flash Player has an extensive list of features that ensure Flash content is secure, including the following:

Uses the encryption capabilities of SSL in the browser to encrypt all communications between a Flash application and the server
Includes an extensive sandbox security system that limits transfer of information that might pose a risk to security or privacy
Does not allow applications to read data from the local drive, except for SharedObjects that were created by that domain
Does not allow writing any data to the disk except for data that is encapsulated in SharedObjects
Does not allow web content to read any data from a server that is not from the same domain, unless that server explicitly allows access
Enables the user to disable the storage of information for any domain
Does not allow data to be sent from a camera or microphone unless the user gives permission

Server Side

Flex Data Services is a J2EE application, so it supports working with the web application security of any J2EE application server. You use J2EE authentication and authorization techniques to prevent unauthorized users from accessing your applications. The Flex Data Services application includes several built-in security mechanisms that let you control access to web services, HTTP services, and Java classes such as EJBs.

(Source:- Adobe)

Security of AJAX Applications

With Web 2.0, a lot of the logic is shifting to the client-side. This may expose the entire application to some serious threats. The urge for data integration from multiple parties and untrusted sources can increase the overall risk factor as well: XSS, XSRF, cross-domain issues and serialization on the client-side and insecure Web services, XML-RPC and REST access on the server-side. Conversely, Ajax can be used to build graceful applications with seamless data integration. However, one insecure call or information stream can backfire and end up opening up an exploitable security hole.

These new technology vectors are promising and exciting to many, but even more interesting to attack, virus and worm writers. To stay secure, this is all the more reason for developers to paying attention to implementation detail.

To deal with Ajax serialization issues validation must be placed on incoming streams before they hit the DOM. XML parsing and cross-domain security issues need extra attention and better security controls. Follow the simple thumb rule of not implementing cross-domain information processing into the browser without proper validation. Interestingly, up until now, the use of client-side scripts for input validation was thoroughly discouraged by security professionals because they can be circumvented easily.

Web 2.0 opens up several new holes around browser security. Exploitation of these security holes is difficult but not impossible. Combinations of security issues and driving factors can open up exploitable holes that impact the sizeable Web community, such as those that can be leveraged by attackers, worms and viruses. Identity compromise may be the final outcome.

(Source Top 10 Ajax Security Holes and Driving Factors)

Scalability

Flex scalability

In most cases, application servers will be configured to work with a load balancer, configured as a cluster, or some combination of the two. Since the Flex Data Services server is a J2EE WAR file, it will participate nicely in these environments.

Flex will scale along with the underlying application server. There are areas where special attention can be paid that will reap additional performance gains. The Flex Data Services messaging features will scale along with the external messaging system integrated with it.

We present below the Scalability test results as documented on the Adobe site. For more details please refer to the study there. These performance test suites test all of the Flex Data Services data access features including RPC services (web service, HTTP service, RemoteObject service), messaging service (using JMS), and data management service.

Source: Adobe

Ajax Scalability

Ajax server interaction is more flexible than page-centric interaction. That flexibility gives you better ability to optimize around whatever measure you care about-including server load.

A really good way to achieve high performance in a web server is to not look at the data you're sending out; just fetch files off the disk (or if you really must, fields out of a database) and pump them down the wire as-is. This allows you to use, almost entirely, the highly-optimized code paths in your filesystem and database and webserver. As soon as the server starts doing dynamic data parsing and mingling at request time, that's a potential performance bottleneck, which can cause a world of pain when you get that real big traffic surge.

(Source: tbray)

Ajax lets us offer new and better services that we could not offer before. Those services are not free, but we accept the server load as a price of doing business.

AJAX enabled applications generate a higher load on an application server than a non AJAX application. Customers will have to size their boxes appropriately as a result. The problem is related to the fact that an AJAX enabled pages simply send more requests to the server because of their high level of interaction versus a conventional web page.

A higher application server load will also translate in to higher database load unless steps are taken to help with this. Distributed caching is a critical piece of the toolkit to help with this. Technologies like ObjectGrid allow an application server to pull data from a remote ObjectGrid cluster in under a ms. It can be used for HTTP session persistence or used directly in the application for more control over how it works, how you lock data etc.

(Source: devwebsphere)

Following packages are designed to handle the extra requests coming from an AJAX application, beyond just optimized coding and good practices.

www.lightstreamer.com - a commercial solution
Jetty 6 Continuations - free, uses new java scaling framework to specifically handle the load of AJAX requests

(Source: Manning Sandbox)

Cross Domain

Sometimes, a web application needs to get data or interact with a server that is not in the same domain as where the application is deployed. Choosing between Flex and AJAX for RIA needs to take care of this scenario as well. Both Flex and AJAX attempt to solve this issue by providing work-arounds to their default security model.

Flex

Adobe® Flash® Player does not allow an application to receive data from a domain other than the domain from which it was loaded, unless it has been given explicit permission. If you load your application (SWF file) from http://mydomain.com, it would not be able to load data from http://yourdomain.com. The only exception is when the server you are contacting has implemented a crossdomain.xml file, which explicitly gives Flash permission to access it. This security sandbox prevents malicious use of the capabilities of Flash Player. JavaScript uses a similar security model to prevent malicious use of JavaScript.

When you need to access data from a Flex application, you have three choices:

Add a crossdomain.xml file to the server with the data.
Upload your SWF file to the same server as the data service.
Create a proxy on your server that calls the data service, and put your SWF file on the same server as the proxy.

Another way to manage Flash Player security is to use a proxy. Adobe® Flex™ Data Services provides a complete proxy management system for Flex applications. You can also create a simple proxy service by using a web scripting language such as ColdFusion, JSP, PHP, or ASP. All the proxy service needs to do is pass requests to the remote service, and pass responses from the remote service back to Flash Player. For more information about creating your own proxy, see adobe's site. During development, one common technique is to host the proxy on your local machine. To do this, you will need to be running a web server and a web scripting language on your local machine.

AJAX

The XMLHttpRequest object implements an interface exposed by a scripting engine that allows scripts to perform HTTP client functionality, such as submitting form data or loading data from the same server. User-agent doesn't allow interacting with other servers because of security reason.

There are a number of solutions to this problem but the most commonly-used one is to install a proxy on your web server. Instead of making your XMLHttpRequest calls directly to the web service, you make your calls to your web server proxy. The proxy then passes the call onto the web service and in return passes the data back to your client application. Because the connection is made to your server, and the data comes back from your server, the browser has nothing to complain about.

(Source: Yahoo)

In addition to using a web proxy to pass web services data to your application, there are several other options to working around cross-domain browser restrictions:

Use apache's mod_rewrite or mod_proxy to pass requests from your server to some other server. In your client code you just make the request as if it was actually on your server -- no browser problems with that. Apache then does its magic and makes the request to the other server for you.
Use JSON and dynamic <script> tags instead of XML and XMLHttpRequest. You can get around the browser security problem altogether by making your web services request directly inside a <script> tag. If the Yahoo! Web Service you're using can output JSON (using the output=json and callback=function parameters), the data you get back from the web service is evaluated as a JavaScript object when the page is loaded. See our JSON Documentation for an example of how to do this in your own scripts.
Digitally sign your scripts. In Firefox you can apply a digital signature to your script and those scripts will then be considered "trusted" by the browser. Firefox will then let you make XMLHttpRequests to any domain. However, no other browsers support script signing at this time, so this solution is of limited use.

For IT Executives

For IT Executives, when it comes to choosing between two competing technologies , be it RIA or any other kind of application, there are a different set of parameters that come into play. These include the availability of developers in these technologies, how easy is it to train in-house developers, if there is enough support available for developers and if it will reduce the cost of building and maintaining the applications.

The following section of the article deals with the issues. In takes a detailed look at how the above parameters could decide which technology to go with if a rich internet application is being built.

Availability of Developers

Flex

Flex has been around for more than three years and has become quite popular with the developers in general. Flex is a technology to build flash applications but it does not require flash authoring skills. This makes it easier for developers with Java or a .NET background to learn Flex. Flex relies on a XML based language(MXML) to build the UI and a object oriented language (ActionScript 3.0) to build logic into the applications. A mid-level Java or .NET developer is familiar with both XML and object oriented languages. Understanding Flex code is easy for these developers and once they are familiar with the syntax, development of new applications is rapid.

Flex is a "red-hot" technology in the market right now and Adobe estimates that there are around 10,000 developers who are familiar with Flex. In terms of finding developers experienced in Flex, it might take some searching to do to find developers with correct skill-set. Flex is becoming quite popular as more and more enterprise level applications are built using it and as a result, there are a lot more developers that are learning Flex, either on the job or by undergoing self or guided training.

AJAX

AJAX, as we know, is not a technology in itself but a term that refers to the use of a group of technologies. These technologies include XHTML, CSS, DOM, XML and ECMAScript implementations like JavaScript and JScript. Most of the mid-level web developers are familiar with these technologies. In order to create AJAX applications, a lot of different frameworks are utilized and these are generally based on the individual technologies mentioned above. As such, developers with these skills are readiliy available.

Ease of training for Developers

Flex

Inkriti has experience in training developers on Flex and it runs both intensive week long training program as well as a 6 weeks 2 hours/day self training. Developers with Java or a .NET background find it the easiest to learn Flex and they do not have unlearn a lot of technologies that they already know - they just have to apply it a bit differently. Flex comprises of MXML and ActionScript - one based on XML and the other an object oriented language. Picking up both of these does not take time. An intensive one week program is suffient for mid-level developers to learn Flex.

Most of the time, Flex applications have to deal with backends that are existing on a Java or .NET architecture. Since Flex interacts with the backend to get data, a fair understanding of Java/.NET is required. This is one of the reasons why developers learn Flex faster - as they just create a UI skin using Flex but integrate that with the existing or new Java/.NET server architecture. Adobe provides a rich set of documentation and there are a number of forums that are dedicated to Flex. Developers find these very useful in learning to build rich internet applications using Flex.

AJAX

If an application is being built using AJAX, the issue is more of choosing the correct AJAX framework that are suited for the application in mind. The web developers can learn these frameworks quite easily as they are aware of the individual technologies that make up the framework. If we take the case of Backbase, a leading provider of scalable and robust AJAX framework, developers can easily pick up the language to create the UI and do server side integration. Some developers might need to get trained more on XML, CSS or JavaScript.

Support Availability

Support plays a big role when IT Executives decide on which technology to go with when building an application. Since RIAs are built using relatively nascent technologies, IT executives need to be convinced that the support provided by these technologies is robust and mature enough. They do not want to be caught unawares in later stages of development if support for certain features is not there. For example, these could happen when the application has been built and is ready to be deployed and there are issues deploying it on secure channels like https or secure transactions with third party vendors like payment gateways. IT Executives want to be doubly sure that the product supports these technologies and there are enough support provided by companies selling these technologies and that they are available via email or phone whenever technology issues come up. Experts available to visit the locations during development or deployment also play a major role in deciding if the technology is good enough to go with in building RIAs.

For AJAX, there are a number of frameworks available to build RIAs and we again take the case of Backbase as it provides a stable enterprise level framework. Both Flex and AJAX are competing commercial products and as such, come with support provided by these companies. Sometimes, support from these companies come at an extra cost.

Flex

The Flex Support center is available at Adobe's site and provides a rich set of articles on different aspects.

Some of the Forums on Flex are:

The other useful online resources are at Adobe's site.

AJAX (Backbase)

For Backbase, the different online resources are at the following locations:

For Business Users

For business users, the issue in deciding on a technology to build RIA generally boils down to the usability of the software and its perception from an end user point of view. The UI components provided RIA technologies - be it Flex or AJAX - go a long way in deciding about what technology to use. Below is an attempt to map out all the UI Components currently provided by these technologies. Please remember that custom components can always be built on top of these UI components provided out-of-the-shelf.

UI Components

UI Component	Flex	Backbase
Buttons
Button	√	√
ButtonBar	√	X
LinkBar	√	√
LinkButton	√	X
PopUpButton	√	X
ToggleButtonBar	√	X

Containers
ApplicationControllerBar	√	√
HDivideBox	√	X
VDivideBox	√	X
Panel	√	√
Box	X	√
PanelSet	X	√

FormElements
CheckBox	√	X
ComboBox	√	√
DateChooser	√	√
NumericStepper	√	√
RadioButton	√	X
TextArea	√	X
TextInput	√	X

List
List	√	√
Tree	√	√
TileList	√	√

Navigators
Accordion	√	√
TabNavigator	√	√
TabBox	X	√

Miscellaneous
ColorPicker	√	X
DataGrid	√	√
MenuBar	√	√
ProgressBar	√	√
ToolTip	√	√
ViewStack	√	√
HSlider	√	√
LiveGrid	X	√
DetailViewer	X	√

Charts
AreaChart	√	X
BarChart	√	X
BubbleChart	√	X
CandlestickChart	√	X
ColumnChart	√	X
HLOCChart	√	X
Legend	√	X
LineChart	√	√
PieChart	√	X
PlotChart	√	X

Conclusion

In the evolution of user interfaces, it is generally agreed that web interfaces are actually a step down from the client server "desktop" interfaces that we are used to. Features like Menus, Drag-drop, Right-click menu and a myriad other wonderful features, that we take for granted in a desktop interface are just not available in a browser.

This article provided a comparative insight of competing RIA technologies such as Flex and AJAX based frameworks. It aimed at developers, IT Executives as well as Business users in order to spell out the issues that they generally face in deciding on Flex or AJAX for their RIAs. It also provided a small survey for executives to quickly decide on what technology would work best for them in terms of their requirements - be in a new or an existing application.

AJAX would work best where security and scalability are not that big an issue, developers are comfortable with Web technologies, you do not want to be tied with proprietary technology and you want to do incremental deployment for some parts of the UI. On the other hand, Flex might be the RIA technology to go with if the application in mind needs a highly secure and scalable deployment, you have access to developers who are comfortable with traditional enterprise technologies, need better access to support and user community, have invested in robust application servers and want a user interface that is generally rich in look and feel and are more interactive.

A proper answer to choosing between the two technologies depends a lot on the situation in hand and we have provided a set of questions that envision such situations. The survey is an effort to present instant suggestions to technology selection though the correct decision will require a more in-depth study of the application. Inkriti offers a one-day review session as well as a one-week prototyping session. Please contact us by mail or by phone if there is an interest on either of these fronts.

Add new comment