Overview

The complex and evolving technology infrastructure of Web 2.0 includes server-software, content-syndication, messaging-protocols, standards-based browsers with plugins and extensions, and various client-applications. These differing but complementary approaches provide Web 2.0 with information-storage, creation, and dissemination capabilities that go beyond what the public formerly expected of web-sites. A Web 2.0 website may typically feature a number of the following techniques:

  • Rich Internet application techniques, optionally Ajax-based
  • CSS
  • Semantically valid XHTML markup and the use of Microformats
  • Syndication and aggregation of data in RSS/Atom
  • Clean and meaningful URLs
  • Extensive use of folksonomies (in the form of tags or tagclouds, for example)
  • Use of wiki software either completely or partially (where partial use may grow to become the complete platform for the site)
  • Use of Open source software either completely or partially, such as the LAMP solution stack
  • Weblog publishing
  • Mashups
  • REST or XML Webservice APIs

We saw various definitions to qualify Web 2.0 and its main technologies. Let us see now closer Ajax and Flex, 2 important technologies in the world of Web 2.0.

Source: Wikipedia

AJAX

Ajax: Definition

Ajax isn’t a technology. It’s really several technologies, each flourishing in its own right, coming together in powerful new ways. Ajax incorporates:

  • standards-based presentation using XHTML and CSS;
  • dynamic display and interaction using the Document Object Model;
  • data interchange and manipulation using XML and XSLT;
  • asynchronous data retrieval using XMLHttpRequest;
  • and JavaScript binding everything together.

The classic web application model works like this: Most user actions in the interface trigger an HTTP request back to a web server. The server does some processing — retrieving data, crunching numbers, talking to various legacy systems — and then returns an HTML page to the client.


Figure 1: The traditional model for web applications (left) compared to the Ajax model (right).

How Ajax is Different

An Ajax application eliminates the start-stop-start-stop nature of interaction on the Web by introducing an intermediary — an Ajax engine — between the user and the server. It seems like adding a layer to the application would make it less responsive, but the opposite is true. Instead of loading a webpage, at the start of the session, the browser loads an Ajax engine — written in JavaScript and usually tucked away in a hidden frame. This engine is responsible for both rendering the interface the user sees and communicating with the server on the user’s behalf. The Ajax engine allows the user’s interaction with the application to happen asynchronously — independent of communication with the server. So the user is never staring at a blank browser window and an hourglass icon, waiting around for the server to do something.


Figure 2: The synchronous interaction pattern of a traditional web application (top) compared with the asynchronous pattern of an Ajax application (bottom).

Every user action that normally would generate an HTTP request takes the form of a JavaScript call to the Ajax engine instead. Any response to a user action that doesn’t require a trip back to the server — such as simple data validation, editing data in memory, and even some navigation — the engine handles on its own. If the engine needs something from the server in order to respond — if it’s submitting data for processing, loading additional interface code, or retrieving new data — the engine makes those requests asynchronously, usually using XML, without stalling a user’s interaction with the application.

Some Examples

  • Google Groups, Google Calendar, Google Maps
  • Flickr
  • Protopage.com

Source : http://www.adaptivepath.com/publications/essays/archives/000385.php

FLEX

Overview

Flex is the solution of development created by Adobe in 2006. It allows creating easily Rich Internet Applications (RIA) multi-platforms. Based on 2 main languages:

  • MXML (rich and interactive user interface)
  • Action Script 3 (basing on ECMAScript), compatible with the new version of flash player 9, close to the language Java. This directed language object allows creating quickly Rich Internet applications.

Easy to use

Flex 2.0 allows us to develop applications without big difficulty thanks to its IDE "flex buider 2", tools of separate development, or if you use Eclipse, the plug-in version is available. The platform of development essentially consists of a language XML, pre-developed graphic components, and a compiler. You can use the various components (label, textbox, menu, datagrid, graphic) with drag and drop while modifying within the language MXML, to obtain the deliberate result. These components ask local or distant services. Developers have the choice between to compile the application - which connects directly from the user post to distant Web services without passing by a server, or then to use the various servers Flex to generate the application in the air and have advanced features. In every case - preliminary compilation or from a server Flex - the applications run on the PC of the user, within the flash player 9.

Source : http://www.adobe.com/fr/products/flex/