Wednesday, July 30, 2008

Spring Framework

The Spring Framework (or Spring for short) is an open source application framework for the Java platform. The first version was written by Rod Johnson, who first released it with the publication of his book Expert One-on-One J2EE Design and Development (Wrox Press, October 2002). A port is available for the .NET Framework.[1]. The Spring 1.2.6 framework won a Jolt productivity award in 2006 [2]

Although the Spring Framework does not enforce any specific programming model, it has become popular in the Java community as an alternative, replacement, or even addition to the Enterprise JavaBean (EJB) model. By design, the framework offers a lot of freedom to Java developers yet provides well documented and easy-to-use solutions for common practices in the industry.

While the core features of the Spring Framework can be used by any Java application, there are many extensions and improvements for building web-based applications on top of the Java Enterprise platform. Spring is popular because of this, and is recognized by vendors as a strategically important framework. [3]

The framework was first released under the Apache 2.0 license in June 2003. The first milestone release, 1.0, was released in March 2004, with further milestone releases in September 2004 and March 2005. Current version is 2.5.5.


The Spring Framework provides solutions to many technical challenges faced by Java developers and organizations wanting to create applications based on the Java platform. Because of the size and complexity of the functionality offered, it can be hard to distinguish the major building blocks from which the framework is composed.[neutrality disputed] The Spring Framework is not exclusively linked to the Java Enterprise platform, although its far-reaching integration in this area is an important reason for its popularity.

The Spring Framework is probably best known for offering features required to create complex business applications effectively outside of the programming models which have been dominant historically in the industry.[neutrality disputed] Next to that, it is also credited for introducing previously unfamiliar functionalities into today's mainstream development practices, even beyond the Java platform.

This amounts to a framework which offers a consistent model and makes it applicable to most application types created on top of the Java platform.


The Spring Framework can be considered as a collection of smaller frameworks. Most of these frameworks are designed to work independently of each other yet provide better functionalities when used together. These frameworks are divided along the building blocks of typical complex applications:

  • Inversion of Control container: configuration of application components and lifecycle management of Java objects.
  • Aspect-oriented programming framework: working with functionalities which cannot be implemented with Java's object-oriented programming capabilities without making sacrifices.
  • Data access framework: working with relational database management systems on the Java platform using JDBC and Object-relational mapping tools providing solutions to technical challenges which are reusable in a multitude of Java-based environments.
  • Transaction management framework: harmonization of various transaction management API's and configurative transaction management orchestration for Java objects.
  • Model-view-controller framework: HTTP and Servlet based framework providing many hooks for extension and customization.
  • Remote Access framework: configurative RPC-style export and import of Java objects over computer networks supporting RMI, CORBA and HTTP-based protocols including web services (SOAP).
  • Authentication and authorization framework: configurative orchestration of authentication and authorization processes supporting many popular and industry-standard standards, protocols, tools and practices via the Spring Security sub-project (formerly Acegi).
  • Remote Management framework: configurative exposure and management of Java objects for local or remote configuration via JMX.
  • Messaging framework: configurative registration of message listener objects for transparent message consumption from message queues via JMS, improvement of message sending over standard JMS API's.
  • Testing framework: support classes for writing unit tests and integration tests.

Inversion of Control container

Central in the Spring Framework is its Inversion of Control container, which provides a consistent means of configuring and managing Java objects using callbacks. This container is also known as BeanFactory, ApplicationContext, or Core container.

The container has many responsibilities and extension points which can all be considered as forms of Inversion of Control, hence its name. Examples are: creating objects, configuring objects, calling initialization methods, and passing objects to registered callback objects. Many of the functionalities of the container together form the object lifecycle, which is one of the most important features it provides.

Objects created by the container are also called Managed Objects or Beans. Typically the container is configured by loading XML files which contain Bean definitions. These provide all the information required to create objects. Once objects are created and configured without raising error conditions, they become available for use.

Objects can be obtained by means of Dependency lookup or Dependency injection. Dependency lookup is a pattern where a caller asks the container object for an object with a specific name or of a specific type. Dependency injection is a pattern where the container passes objects by name to other objects, via either constructors, properties, or factory methods.

In many cases it's not necessary to use the container when using other parts of the Spring Framework, although using it will likely make an application easier to configure and customize. The Spring container provides a consistent mechanism to configure applications and integrates with almost all Java environments, from small-scale applications to large enterprise applications[citation needed].

The container can be turned into a partially-compliant EJB3 container by means of the Pitchfork project. The Spring Framework is criticized by some as not being standards compliant. However, SpringSource doesn't see EJB3 compliance as a major goal, and claims that the Spring Framework and the container allow for more powerful programming models.[4]

Aspect-oriented programming framework

The Spring Framework has its own AOP framework which modularizes cross-cutting concerns in aspects. The motivation for creating a separate AOP framework comes from the belief that it would be possible to provide basic AOP features without too much complexity in either design, implementation, or configuration. The Spring AOP framework also takes full advantage of the Spring Container.

The Spring AOP framework is interception based, and is configured at runtime. This removes the need for a compilation step or load-time weaving. On the other hand, interception only allows for public or protected method execution on existing objects at a join point.

Compared to the AspectJ framework, Spring AOP is less powerful but also less complicated. Spring 1.2 includes support to configure AspectJ aspects in the container. Spring 2.0 has more integration with AspectJ; for example, the pointcut language is reused.

Spring AOP has been designed to make it able to work with cross-cutting concerns inside the Spring Framework. Any object which is created and configured by the container can be enriched using Spring AOP.

The Spring Framework uses Spring AOP internally for transaction management, security, remote access, and JMX.

Since version 2.0 of the framework, Spring provides two approaches to the AOP configuration:

  • schema-based approach
  • @AspectJ-based annotation style

The Spring team decided not to introduce new AOP-related terminology; therefore, in the Spring reference documentation and API, terms such as aspect, join point, advice, pointcut, introduction, target object (advised object), AOP proxy, and weaving all have the same meanings as in most other AOP frameworks (particularly AspectJ).

Data access framework

Spring's data access framework addresses common difficulties developers face when working with databases in applications. Support is provided for all popular data access frameworks in Java: JDBC[1], iBatis[2], Hibernate[3], JDO[4], JPA[5], Oracle TopLink, Apache OJB[6], and Cayenne[7], among others.

For all of these supported frameworks, Spring provides these features:

  • Resource management - automatically acquiring and releasing database resources
  • Exception handling - translating data access related exception to a Spring data access hierarchy
  • Transaction participation - transparent participation in ongoing transactions
  • Resource unwrapping - retrieving database objects from connection pool wrappers
  • Abstraction for BLOB and CLOB handling

All these features become available when using Template classes provided by Spring for each supported framework. Critics say these Template classes are intrusive and offer no advantage over using (for example) the Hibernate API directly.[8] In response, the Spring developers have made it possible to use the Hibernate and JPA APIs directly. This however requires transparent transaction management, as application code no longer assumes the responsibility to obtain and close database resources, and does not support exception translation.

Together with Spring's transaction management, its data access framework offers a flexible abstraction for working with data access frameworks. The Spring Framework doesn't offer a common data access API; instead, the full power of the supported APIs is kept intact. The Spring Framework is the only framework available in Java which offers managed data access environments outside of an application server or container.[citation needed]

While using Spring for transaction management with Hibernate, following beans may be required to be configured

  • DataSource like com.mchange.v2.c3p0.ComboPooledDataSource or org.apache.commons.dbcp.BasicDataSource
  • SessionFactory like org.springframework.orm.hibernate3.LocalSessionFactoryBean
  • HibernateProperties like org.springframework.beans.factory.config.PropertiesFactoryBean
  • TransactionManager like org.springframework.orm.hibernate3.HibernateTransactionManager

Other configurations

  • AOP configuration of cutting points using
  • Transaction semantics of AOP advice using

Transaction management framework

Spring's transaction management framework brings an abstraction mechanism to the Java platform. Its abstraction is capable of:

In comparison, JTA only supports nested transactions and global transactions, and requires an application server (and in some cases also deployment of applications in an application server).

The Spring Framework ships a PlatformTransactionManager for a number of transaction management strategies:

  • Transactions managed on a JDBC Connection
  • Transactions managed on Object-relational mapping Units of Work
  • Transactions managed via the JTA TransactionManager and UserTransaction
  • Transactions managed on other resources, like object databases

Next to this abstraction mechanism the framework also provides two ways of adding transaction management to applications:

  • Programmatically, by using Spring's TransactionTemplate
  • Configuratively, by using metadata like XML or Java 5 annotations

Together with Spring's data access framework — which integrates the transaction management framework — it is possible to set up a transactional system through configuration without having to rely on JTA or EJB. The transactional framework also integrates with messaging and caching engines.

Model-view-controller framework

The Spring Framework features its own MVC framework, which wasn't originally planned. The Spring developers decided to write their own web framework as a reaction to what they perceived as the poor design of the popular Jakarta Struts web framework[9], as well as deficiencies in other available frameworks. In particular, they felt there was insufficient separation between the presentation and request handling layers, and between the request handling layer and the model.[5]

Like Struts, Spring MVC is a request-based framework. The framework defines strategy interfaces for all of the responsibilities which must be handled by a modern request-based framework. The responsibility of each interface is sufficiently simple and clear that it's easy for Spring MVC users to write their own implementations if they choose to[neutrality disputed]. All interfaces are tightly coupled to the Servlet API to offer the full power of this API. This tight coupling to the Servlet API is seen by some as a failure on the part of the Spring developers to offer a high-level abstraction for web-based applications[citation needed]. However, this coupling makes sure that the features of the Servlet API remain available to developers while offering a high abstraction framework to ease working with said API.

The DispatcherServlet class is the front controller [10] of the framework and is responsible for delegating control to the various interfaces during the execution phases of an HTTP request.

The most important interfaces defined by Spring MVC, and their responsibilities, are listed below:

  • HandlerMapping: selecting objects which handle incoming requests (handlers) based on any attribute or condition internal or external to those requests
  • HandlerAdapter: execution of objects which handle incoming requests
  • Controller: comes between Model and View to manage incoming requests and redirect to proper response.
  • View: responsible for returning a response to the client
  • ViewResolver: selecting a View based on a logical name for the view (use is not strictly required)
  • HandlerInterceptor: interception of incoming requests comparable but not equal to Servlet filters (use is optional and not controlled by DispatcherServlet).
  • LocaleResolver: resolving and optionally saving of the locale of an individual user
  • MultipartResolver: facilitate working with file uploads by wrapping incoming requests

Each strategy interface above has an important responsibility in the overall framework. The abstractions offered by these interfaces are sufficiently powerful to allow for a wide set of variations in their implementations. Spring MVC ships with implementations of all these interfaces and together offers a powerful feature set on top of the Servlet API[neutrality disputed]. However, developers and vendors are free to write other implementations. Spring MVC uses the Java java.util.Map interface as a data-oriented abstraction for the Model where keys are expected to be string values.

The ease of testing the implementations of these interfaces is one important advantage of the high level of abstraction offered by Spring MVC. DispatcherServlet is tightly coupled to the Spring Inversion of Control container for configuring the web layers of applications. However, applications can use other parts of the Spring Framework—including the container—and choose not to use Spring MVC.

Because Spring MVC uses the Spring container for configuration and assembly, web-based applications can take full advantage of the Inversion of Control features offered by the container.

Remote access framework

Spring's Remote Access framework is an abstraction for working with various RPC-based technologies available on the Java platform both for client connectivity and exporting objects on servers. The most important feature offered by this framework is to ease configuration and usage of these technologies as much as possible by combining Inversion of Control and AOP.

The framework also provides fault-recovery (automatic reconnection after connection failure) and some optimizations for client-side use of EJB remote stateless session beans.

Spring provides support for these protocols and products out of the box:

  • HTTP-based protocols
    • Hessian: binary serialization protocol, open-sourced and maintained by Corba-based protocols
    • RMI (1): method invocations using RMI infrastructure yet specific to Spring
    • RMI (2): method invocations using RMI interfaces complying with regular RMI usage
    • RMI-IIOP (Corba): method invocations using RMI-IIOP/Corba
  • Enterprise JavaBean client integration
    • Local EJB stateless session bean connectivity: connecting to local stateless session beans
    • Remote EJB stateless session bean connectivity: connecting to remote stateless session beans
  • SOAP
    • Integration with the Apache Axis web services framework

The XFire SOAP framework provides integration with the Spring Framework for RPC-style exporting of object on the server side.

Both client and server setup for all RPC-style protocols and products supported by the Spring Remote access framework (except for the Apache Axis support) is configured in the Spring Core container.

There is alternative open-source implementation (Cluster4Spring) of a remoting subsystem included into Spring Framework which is intended to support various schemes of remoting (1-1, 1-many, dynamic services discovering).


Wednesday, July 16, 2008

PRADO PHP Framework

From : Prado

PRADO is a component-based and event-driven framework for rapid Web programming in PHP 5. PRADO reconceptualizes Web application development in terms of components, events and properties instead of procedures, URLs and query parameters.

A PRADO component is a combination of a specification file (in XML), an HTML template and a PHP class. PRADO components are combined together to form larger components or complete PRADO pages.

Developing PRADO Web applications mainly involves instantiating prebuilt and application-specific component types, configuring them by setting their properties, responding to their events by writing handler functions, and composing them into application tasks. Event-driven programming

PRADO provides the following benefits for Web application developers:

  • reusability - Codes following the PRADO component protocol are highly reusable. Everything in PRADO is a reusable component.
  • ease of use - Creating and using components are extremely easy. Usually they simply involve configuring component properties.
  • robustness - PRADO frees developers from writing boring, buggy code. They code in terms of objects, methods and properties, instead of URLs and query parameters. The latest PHP5 exception mechanism is exploited that enables line-precise error reporting.
  • performance - PRADO uses a cache technique to ensure the performance of applications based on it. The performance is in fact comparable to those based on commonly used template engines.
  • team integration - PRADO enables separation of content and presentation. Components, typically pages, have their content (logic) and presentation stored in different files.

Sunday, July 13, 2008

Akelos PHP Framework

From : Akelos

The Akelos PHP Framework is a web application development platform based on the MVC (Model View Controller) design pattern. Based on good practices, it allows you to:

  • Write views using Ajax easily
  • Control requests and responses through a controller
  • Manage internationalized applications
  • Communicate models and the database using simple conventions.

Your Akelos based applications can run on most shared hosting service providers since Akelos only requires that PHP be available at the server. This means that the Akelos PHP Framework is the ideal candidate for distributing standalone web applications as it does not require any non-standard PHP configuration to run.

Who can benefit from the Akelos PHP Framework?

  • Web developers writing database applications using PHP.
  • PHP developers who want a more enjoyable experience writing applications.
  • Ruby developers that need to code in PHP and want an easier and more enjoyable way to do so.
  • Companies and developers looking to sell or distribute their applications without requiring special deployment configurations.
  • Developers looking to develop multilingual applications for localized markets.
  • Development teams that require a method with a few simple conventions to ensure that team members will understand the work done by their peers.

Being a Ruby on Rails port to PHP, Akelos is also designed to make developers lives simpler by resolving complex problems with unusual speed and productivity.

Favoring "convention over configuration" leads to the creation of uniform and simpler-to-understand code.

If you want to know more about the Akelos PHP Framework, why not view the video "Creating a Blog in 20 minutes" video?

Who is already using Akelos

Akelos has evolved from the work done on many complex intranet sites that, unfortunately, are not public. Here are some public projects using the Akelos PHP Framework:


If you feel that the features of the Akelos PHP Framework don't match your needs, you can look at these other web application Frameworks.

Akelos PHP Framework Features

The Akelos PHP Framework implements many features from Ruby on Rails and some others targeted to coding multilingual applications which need to be distributed in a simple manner.

Akelos Main Goals

  • Improve developer happiness.
  • Speed up the creation of complex web applications writing less code.
  • Provide all the means for creating applications that can run on cheap PHP4/PHP5 hosts and in the developer desktop without complex configurations.
  • Help on the hard task of creating and maintaining applications with data and views in multiple languages.
  • Favor conventions over configurations.

Features ported from Ruby on Rails

Active Record

  • Associations

    • belongs_to
    • has_one
    • has_many
    • has_and_belongs_to_many
    • Finders - not so cool as Ruby on Rails but you can still do
      $Project->findFirstBy('language AND start_year:greater', 'PHP', '2004');
    • Acts as
    • nested_set
    • list
  • Callbacks
  • Transactions
  • Validators
  • Locking
  • Observer
  • Versioning
  • Scaffolds
  • Support for MySQL, PostgreSQL and SQLite (might work with other databases supported by ADOdb)

Action Controller

  • Filters
  • Pagination
  • Helpers
  • Mime Type
  • Mime Response
  • Code Generation
  • Flash messages
  • URL Routing
  • Response handler
  • Url rewriter

Action View

Additional Akelos PHP Framework Features

  • Multilingual Models and Views
  • Locale alias integrated on URLS ( will load the es_ES locale)
  • Pure PHP support for Unicode (no extensions required)
  • Unit Tested source code using simpletest
  • PHP Code Generators
  • Built in XHTML validator
  • Automated locale management
  • Ajax file uploads.
  • Format converters.
  • File handling using FTPS for shared hosts where Apache runs as user nobody.
  • Distributed sessions using databases.
  • Cache system using a unique interface independent of the medium Database, Files or Memory.

Thursday, July 10, 2008

The Most Complete AJAX Framework and JavaScript Libraries List (124+)

Ajax framework can help us to quickly develop web pages that can call web services and server pages through javascript without having to submit the current page.Recent Web-applications tend to use them to provide more interactivity and guarantee better functionality.There are hundreds of Ajax/JavaScript frameworks available — I spent some days to gather the most useful of them,if you know others not include in the list,don’t hesitate to leave your comment.:)

1. dojo
“dojo” is a Japanese term which literally means “place of the Way”.Here,dojo is an Open Source DHTML toolkit written in JavaScript. It builds on several contributed code bases.Dojo aims to solve some long-standing historical problems with DHTML which prevented mass adoption of dynamic web application development.You can use the lower-level APIs and compatibility layers from Dojo to write portable JavaScript and simplify complex scripts. Dojo’s event system, I/O APIs, and generic language enhancement form the basis of a powerful programming environment.It makes professional web development better, easier, and faster.

Rico is an open source JavaScript framework used to create and extend Ajax-based web applications. It includes drag-and-drop functionality, and can programmatically round HTML elements.Rico provides a very simple interface for registering Ajax request handlers as well as HTML elements or JavaScript objects as Ajax response objects. Multiple elements and/or objects may be updated as the result of one Ajax request.

Rico is released under the Apache License, and is based on the Prototype Javascript Framework.

qooxdoo is a comprehensive and innovative Ajax application framework.It includes a platform-independent development tool chain, a state-of-the-art GUI toolkit and an advanced client-server communication layer.It helps you to implement professional AJAX-enhanced web 2.0 applications.

qooxdoo is under an LGPL/EPL dual license.

Maybe TIBET is the oldest AJAX project.It seems stop but we can find the TIBET team’s new vision (here) for Client/SOA using AJAX, JSON, and the virtual machine you call a web browser has been the driving force behind TIBET.

5.Flash/JavaScript Integration kit
The Flash JavaScript Integration Kit allows developers to get the best of the Flash and HTML worlds by enabling JavaScript to invoke ActionScript functions, and vice versa. All major data types(objects,arrays,strings,numbers,dates,booleans,nulls,undefined) can be passed between the two environments.The Flash JavaScript Integration Kit makes it possible to seamlessly communicate between Flash and JavaScript.Of course,it works across all major browsers and operating systems.

The Flash / JavaScript Integration kit is released under an open license (modeled after the Apache 1.1 license).

6.Google AJAXSLT
AJAXSLT is an implementation of XSL-T in JavaScript, intended for use in fat web pages, which are nowadays referred to as AJAX applications.Because XSLT uses XPath, it is also an implementation of XPath that can be used independently of XSLT. This implementation has the advantange that it makes XSLT uniformly available on more browsers than natively provide it, and that it can be extended to yet more browsers if necessary.AJAXSLT is interesting for developers who strive aggressively for cross browser compatibility of their advanced web applications.

Google AJAXSLT is released under an open license New BSD License.

It is a very simple wrapper around XHR.The XmlRequest library contains a two public request functions, getXml and postXml, that may be used to send synchronous and asynchronous XML Http requests from Internet Explorer and Mozilla.

RSlite is an extremely lightweight implementation of remote scripting which uses cookies. It is very widely browser-compatible (Opera!) but limited to single calls and small amounts of data.

A simple set of code to allow you to put AJAX into your webpages with none of the fuss or overhead of other packages.It makes using AJAX simpler, and easy to implement.

SACK is released under a Modified X11 licence.


Sarissa is an ECMAScript library acting as a cross-browser wrapper for native XML APIs. It offers various XML related goodies like Document instantiation, XML loading from URLs or strings, XSLT transformations, XPath queries etc and comes especially handy for people doing what is lately known as “AJAX” development.


XHConn is a small Javascript library that exposes a data object with a single method: connect.

Invoking this method creates an asynchronous XMLHTTPRequestt and then triggers the specified callback function with the server’s response.


CPAINT (Cross-Platform Asynchronous INterface Toolkit) is a multi-language toolkit that helps web developers design and implement AJAX web applications with ease and flexibility. It was originally born out of the author’s frustration and disappointment with other open-source AJAX toolkits. It is built on the same principles of AJAX, utilizing JavaScript and the XMLHTTP object on the client-side and the appropriate scripting language on the server-side to complete the full circle of data passing from client to server and back.


Sajax (Simple Ajax Toolkit), is an open source tool designed to help websites using the Ajax framework (also known as XMLHttpRequest). It allows the programmer to call ASP, ColdFusion, Io, Lua, PHP, Perl, Python, or Ruby functions from their webpages via JavaScript without performing a browser refresh.


JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language.

15.Direct Web Remoting

In the simplest terms, DWR is an engine that exposes methods of server-side Java objects to JavaScript code. Effectively, with DWR, you can eliminate all of the machinery of the Ajax request-response cycle from your application code. This means your client-side code never has to deal with an XMLHttpRequest object directly, or with the server’s response. You don’t need to write object serialization code or use third-party tools to turn your objects into XML. You don’t even need to write servlet code to mediate Ajax requests into calls on your Java domain objects.


Swato is an opensource framework that help you develop your webapps easier.

The server side Java library can be easily deployed in all Servlet 2.3+ compatible containers. The client side JavaScript library is base on prototype that can help you coding your JavaScript in the OO way. Using JSON to marshalling the data of your POJOs on server side. Providing a simple interface for your JavaScript code to interactive with the remote POJOs exposed to the client side. (RPC,cross domain access) Easy and flexible configuration using servlet and filter in web.xml and comes with Spring integration. Comes with several reusable component (Auto-suggest Textbox, JS Template, JS Logger, etc) that help you develop your web apps easier.

17.Java BluePrints

Java BluePrints is Sun Microsystems’ best practices for Enterprise Java development. This is Sun’s official programming model for Java 2 Platform, Enterprise Edition (J2EE) Software Development Kit (SDK). It began with Java Pet Store, the original reference application for the J2EE platform. This became the de facto source code for using Enterprise Java Beans and all the latest components of the J2EE platform.


Ajax.NET Professional, or Ajax.NET for short, is Michael Schwarz’s free Ajax add-on library for implementing Ajax functionality within the Microsoft .NET Framework. This was the first Ajax framework developed for ASP.NET 1.x/2.0, providing very basic Ajax capabiliti


ASP.NET AJAX is a free framework for quickly creating efficient and interactive Web applications that work across all popular browsers.

20.Ruby on Rails

Rails is a full-stack framework for developing database-backed web applications according to the Model-View-Control pattern. From the Ajax in the view, to the request and response in the controller, to the domain model wrapping the database, Rails gives you a pure-Ruby development environment. To go live, all you need to add is a database and a web server.

A JavaScript Library for Macromedia’s Flash™ Platform. AFLAX is a method through which developers may use JavaScript and Flash together to create AJAX-type applications, but with a much richer set of vector drawing controls than are available in either Internet Explorer or FireFox. Developers using this library have access to the full range of Flash features, but without ever touching the Flash IDE.


AjaxAC is an open-source framework written in PHP, used to develop/create/generate AJAX applications. The fundamental idea behind AJAX (Asynchronous JavaScript And XML) is to use the XMLHttpRequest object to change a web page state using background HTTP sub-requests without reloading the entire page.


AJAXExtended is a JavaScript library that improves standard XMLHttpRequest features. The most important enhancement

24.Ajax.NET Professional

Ajax.NET Professional (AjaxPro) is one of the first AJAX frameworks available for Microsoft ASP.NET and is working with .NET 1.1 and 2.0.

25.AjaxRequest Library

AjaxRequest is a layer over the XMLHttpRequest functionality which makes the communication between Javascript and the server easier for developers.

26.AHAH: Asychronous HTML and HTTP

AHAH is a very simple technique for dynamically updating web pages using JavaScript. It involves using XMLHTTPRequest to retrieve (X)HTML fragments which are then inserted directly into the web page, whence they can be styled using CSS.


Bajax its a very small and simple javascript library to use Ajax on your pages. independent of programming language. You can put dynamic content using simple commands

28.Code Snippets

Snippets is a public source code repository. Easily build up your personal collection of code snippets, categorize them with tags / keywords, and share them with the world.

This site features X - a cross-browser DHTML javascript library, and many demos, applications, articles and documentation.

30.DHTML API, Drag & Drop for Images and Layers

A Cross-browser JavaScript DHTML Library which adds Drag Drop functionality and extended DHTML capabilities to layers and to any desired image, even those integrated into the text

A library of DHTML and AJAX scripts

32.DHTML Kitchen

DHTML Kitchen is your resource for ready-made or custom-built DHTML scripts. We also specialize in JSP, and front-end Java solutions.


dp.SyntaxHighlighter is a free JavaScript tool for source code syntax highlighting

34.Dynamic Drive

DHTML & JavaScript code library


DynAPI 3 is an open-sourced project initiated by Dan Steinman, created to make cross-browser Dynamic HTML a reality. The DynAPI library uses an object-oriented approach to solve problems associated with scripting for both Netscape and Internet Explorer.

36.Ext JS (javascript library)

an open-source JavaScript library, for building richly interactive web applications using techniques such as AJAX, DHTML and DOM scripting.

It extends the Web. World-class JavaScript, Ajax and UI Components.

37.Engine for Web Applications

Engine for Web Applications is an application framework for client-side development and Web applications. It provides an environment in which to develop and run JavaScript components and applications.


A way to easily bring life and interactivity to websites without having to use Flash. Completely accessible, with easy plug-and-play implementation.

39.JSL : JavaScript Standard Library

JSL is a single and small file ( IE4 compatible packed version: 7.77 Kb ) with some JavaScript 1.6 standard methods or functions that are not present on some browsers. Its goals is to forget work arounds for every library or script that’s included on a web page. You could just add JSL even before your scripts to add portability or more compatibility, then you don’t need to rewrite anything.

40.Javascript Toolbox

This site is intended to be a repository of code and reusable libraries which address common needs that many web developers encounter. The code found here is based on standards but also tries to be backwards-compatible for browsers which don’t support the standards

41.jQuery - New Wave Javascript

jQuery is a Javascript library that takes this motto to heart: Writing Javascript code should be fun. jQuery achieves this goal by taking common, repetitive, tasks, stripping out all the unnecessary markup, and leaving them short, smart and understandable.

42.JSAN - JavaScript Archive Network

JavaScript Archive Network is a comprehensive resource for Open Source JavaScript libraries and software.

43.JSFBGL - Javascript framebuffer graphics library

JSFBGL (i.e. Javascript framebuffer graphics library) is considered as an art/fun project. So do not take it too seriously. Since all the webV2.0/AJAX hype which is going on atm I started to think about a way to produce graphics with javascript. And this is the result. I don’t know if this is the most efficient way - but it works as a proof of concept.

44.Kabuki AJAX Toolkit

Kabuki AjaxTK is a client developer library, similar in style to traditional object-oriented widget libraries like E9clipse’s SWT, albeit for Javascript.

45.LINB(Lazy INternet and Browser)

LINB(Lazy INternet and Browser) is designed to allow developers coding in a more targetable, clearly, and efficiently way. LINB is platform-independent, language-independent, and C/S, B/S, RIA compatible.


JavaScript Basic library - iberty gives you the Basic shit to make web development with JavaScript comfortable. 47.


“MochiKit makes JavaScript suck less.” MochiKit is a highly documented and well tested, suite of JavaScript libraries that] will help you get shit done, fast. We took all the good ideas we could find from our Python, Objective-C, etc. experience and adapted it to the crazy world of JavaScript.


moo.ajax is a very simple ajax class, to be used with prototype.lite from moo.fx.


moo.fx is a superlightweight, ultratiny, megasmall javascript effects library, written with prototype.js.


overLIB is a JavaScript library created to enhance websites with small popup information boxes (like tooltips) to help visitors around your website.


overLIB is a JavaScript library created to enhance websites with small popup information boxes (like tooltips) to help visitors around your website.

52.overlibmws DHTML Popup Library

Download and Test Directory for the overlibmws DHTML Popup Library

53.Plex Toolkit

Open source feature-complete DHTML GUI toolkit and AJAX framework based on a Javascript/DOM implementation of Macromedia’s Flex technology. Uses the almost identical markup language to Flex embedded in ordinary HTML documents for describing the UI. Binding is done with Javascript.

54.PlotKit - Javascript Chart Plotting

PlotKit is a Chart and Graph Plotting Library for Javascript


Prototype is a JavaScript framework that aims to ease development of dynamic web applications. Its development is driven heavily by the Ruby on Rails framework, but it can be used in any environment.

56.qForms JavaScript API

the most complete JavaScript API for interfacing forms. The qForms API has been designed to make forms easy to work with. It simplifies tasks HTML developers normally find tricky to handle


sardalya is a cross-browser interface that aims to make dynamic HTML programming easy and fun. It is a cross-browser compatible system which is designed to work in all DOM-supporting browsers. provides you with easy-to-use, cross-browser user interface JavaScript libraries to make your web sites and web applications fly

59.JonDesign’s Smooth SlideShow Library

Using moo.fx and prototype.lite.js, this javascript slideshow system allows you to have a simple and smooth (cross-fading…) image slideshows and/or showcases on you website.

60.Spry Framework for Ajax

Adobes Spry framework for Ajax is a JavaScript library for web designers that provides functionality that allows designers to build pages that provide a richer experience for their users.


This library is a simple way to implement tabs on your page using CSS, a little JS, and semantic markup which degrades gracefully on browsers with CSS unavailable or disabled.


Taconite is a framework that simplifies the creation of Ajax enabled Web applications. It’s a very lightweight framework that automates the tedious tasks related to Ajax development, such as the creation and management of the XMLHttpRequest object and the creation of dynamic content…


The Tacos library project provides components and ajax behaviour for the Tapestry java web application framework. Most of the functionality is based on the exceptional dojo javascript library.

64.The Solvent

The Solvent is a cross-browser AJAX application toolkit written in JavaScript. The Solvent is provided as modules or as an entire toolkit. The projects focus is to promote robust web applications and enable rapid web development.


ThyAPI is an api to allow the developement of better user interfaces for web applicaticions, Using javascript and Ajax, it allows a complete visual interface definition using CSS and encapsulates all objects data manipulateion. Build over DynApi.


Portfolio of original, high-performance DHTML and JavaScript examples. Designed them all to be as small as possible (once you trim out the comments, of course) and fast — small code is my main priority when developing scripts, as users don’t want to wait half an hour for their site to load”.


TurboWidgets are JavaScript client-side controls that provide a rich user-interface experience for AJAX-style web applications. Built on top of the popular Dojo Toolkit, TurboWidgets are designed for ease-of-use and flexibility. Please see the dev-o-meter for latest developments.

68.UIZE JavaScript API

JavaScript Examples

69.High Performance JavaScript Vector Graphics Library

This JavaScript VectorGraphics library provides graphics capabilities for JavaScript: functions to draw circles, ellipses (ovals), oblique lines, polylines and polygons (for instance triangles, rectangles) dynamically into a webpage.

71.WMS Javascript Library

A Web Map Server (WMS) will return a static map image if given the required parameters in the URL. The purpose of the WMS Javascript Library wmsmap.js is to facilitate the creation of dynamics maps using freely available WMS servers…

72.Yahoo Design Pattern Library

73.Yahoo! User Interface Library

The Yahoo! User Interface (YUI) Library is a set of utilities and controls, written in JavaScript, for building richly interactive web applications using techniques such as DOM scripting, DHTML and AJAX…

74.Yahoo! UI Library

75.Zapatec AJAX Suite

Jump start your AJAX deployment by using the Zapatec suite which includes six widgets, three modules and a library. Don’t be intimidated by the Suite’s breadth, its components are built with ease of use in mind, and you can start with one or two and migrate to using the full suite as your needs and familiarity increase.


Zebda is a general purpose javascript library built on Prototype 1.4.0.


Zephyr is an ajax based framework for php5 developers. you can easily develop business applications using this robust framework. this is extremely easy to learn and very simple to implement


ZK is an open-source Ajax Web framework that enables rich user interface for Web applications with no JavaScript and little programming.


Enterprise Ajax Framework.


a compact and modular JavaScript framework best known for its visual effects and transitions.

81.Clean AJAX

Clean is an open source engine for AJAX, that provides a high level interface to work with the AJAX technology.


Wt(witty) is a WebToolkit, allowing programmers to write code in C++ (without real knowledge of Ajax), generating content rich Ajax GUI. OpenSource Licence.


Echo is a web application framework that was created by the company NextApp. It originally started as a request-response web application framework that leveraged the Swing object model to improve the speed of application development. Through the use of the swing model, Echo was able to employ concepts such as components and event-driven programming that removed much of the pain of web application development.

84.Google Web Toolkit

Google Web Toolkit (GWT) is an open source Java software development framework that allows web developers to create Ajax applications in Java. It is licensed under the Apache License version 2.0.

GWT emphasizes reusable, efficient solutions to recurring Ajax challenges, namely asynchronous remote procedure calls, history management, bookmarking, and cross-browser portability.


ThinWire is an open source, Java based web application framework that utilizes Ajax techniques to give Web Applications the look and feel of traditional GUI applications.


Symfony is a web application framework written in PHP which follows the model-view-controller (MVC) paradigm. Released under the MIT license, Symfony is free software. The website launched on October 18, 2005.


Tigermouse is a modern Ajax driven MVC framework for web applications development.


xajax is an open source PHP class library implementation of AJAX that allows developers to create web-based Ajax applications using HTML, CSS, JavaScript, and PHP. Applications developed with xajax can asynchronously call server-side PHP functions and update content without reloading the page.


AjaxAnywhere is a simple way to enhance an existing JSP/Struts/Spring/JSF application with AJAX. It uses AJAX to refresh “zones” on a web page, therefore AjaxAnywhere doesn’t require changes to the underlying code, so while it’s more coarse than finely-tuned AJAX, it’s also easier to implement, and doesn’t bind your application to AJAX (i.e., browsers that don’t support AJAX can still work.). In contrast to other solutions, AjaxAnywhere is not component-oriented. You will not find here yet another AutoComplete component. Simply separate your web page into multiple zones, and use AjaxAnywhere to refresh only those zones that needs to be updated.

90. ajaxCFC

ajaxCFC is a ColdFusion framework meant to speed up ajax application development and deployment by providing developers seamless integration between JavaScript and ColdFusion, and providing built-in functions to quickly adapt to any type of environment, security, and helping to overcome cross-browser compatibility problems.

ajaxCFC is designed as ColdFusion components, following the best practices of object oriented programming and design patterns. Programming with ajaxCFC involves extending components and creating your own ajax facades.

91.AjaxTags component of Java Web Parts

AjaxTags was originally an extended version of the Struts HTML taglib, but was made into a generic taglib (i.e., not tied to Struts) and brought under the Java Web Parts library. AjaxTags is somewhat different from most other Ajax toolkits in that it provides a declarative approach to Ajax. You configure the Ajax events you want for a given page via XML config file, including what you want to happen when a request is sent and when a response is received. This takes the form of request and response handlers. A number of rather useful handlers are provided out-of-the-box, things like updating a
, sending a simple XML document, transforming returned XML via XSLT, etc. All that is required to make this work on a page is to add a single tag at the end, and then one following whatever page element you want to attach an Ajax event to. Any element on a page can have an Ajax event attached to it. If this sounds interesting, it is suggested you download the binary Java Web Parts distro and play with the sample app. This includes a number of excellent examples of what AjaxTags can do.


AJS is a ultra lightweight JavaScript library. It’s only about 30 KB. AJS main force is performance - both in execution and file size. It has a lot of functionality in common with MochiKit.


Anaa means for An Ajax API and is a simple but complete framework built around XMLHttpRequest?. Anaa does support GET and POST methods. Plain Text (including JSON) and XML file are handled.

94.DotNetRemoting Rich Web Client SDK for ASP.NET

Rich Web Client SDK is a platform for developing rich internet applications (including AJAX). The product is available for .NET environment and includes server side DLL and a client side script


Fleegix.js provides a lightweight, cross-browser set of JavaScript tools for building dynamic Web-app UIs.

Includes a concise but powerful events system, an industrial-strength XHR library, a simple, no-muss-no-fuss XML parser, and some handy tools for working with Web forms, as well as other basic tools you need to build an Ajaxy Web UI.


Excellent cross-browser compatibility (e.g. works with IE 5.0 with disabled ActiveX).
Support and “transparent” work with any character encoding (including any national).
AJAX file uploads from a user browser to the server without a page reloading.
Full support of PHP debug features and coding traditions.
Multi-dimensional data structures exchange (associative arrays).
Automatic choice of the best AJAX realization (XMLHttpRequest, SCRIPT, IFRAME).
XMLHttpRequest-compatible interface is available.

The main idea of JsHttpRequest is to be simple and transparent for all programmers and habitual programming techniques.

* PHP notices and errors (including fatal) are not break the script execution;
* there is no need of any framework (e.g. classes) to build a server part;
* PHP arrays are converted to JS objects and back fully transparently;
* forget about national encodings problems (e.g. works with windows-1251 on PHP part).


JSON-RPC-Java is a key piece of Java web application middleware that allows JavaScript DHTML web applications to call remote methods in a Java Application Server (remote scripting) without the need for page reloading (as is the case with the vast majority of current web applications). It enables a new breed of fast and highly dynamic enterprise Java web applications (using similar techniques to Gmail and Google Suggests).


Rialto is a cross browser javascript widgets library. Because it is technology agnostic it can be encapsulated in JSP, JSF, .Net or PHP graphic components.

99.Scriptaculous provides you with easy-to-use, compatible and, ultimately, totally cool! JavaScript libraries to make your web sites and web applications fly, Web 2.0 style. A lot of the more advanced Ajax support in Ruby on Rails (like visual effects, auto-completion, drag-and-drop and in-place-editing) uses this library.

100.SmartClient from Isomorphic Software

SmartClient is the cross-platform AJAX GUI system chosen by top commercial software vendors, on-demand service providers, and enterprise IT developers for thousands of deployments since 2000.

SmartClient provides a complete application stack, from rich, skinnable, extensible GUI components to declarative databinding and SOA integration, paired with a mature, searchable documentation suite and integrated tooling.

SmartClient AJAX applications run on Internet Explorer, Mozilla, Netscape, Firefox, and Safari web browsers, on Windows, MacOS, Linux, and Solaris. A Java integration server is provided, and SmartClient can also be integrated directly with any XML or JSON-based service without need of a server. Visit for hundreds of live examples, browseable documentation and a downloadable SDK.

101.TIBCO General Interface (AJAX RIA Framework and IDE since 2001)

TIBCO General Interface is a mature AJAX RIA framework that’s been at work powering applicaitions at Fortune 100 and US Government organziations since 2001. Infact the framework is so mature, that TIBCO General Interface’s visual development tools themselves run in the browser alongside the AJAX RIAs as you create them.

ee an amazing demo in Jon Udell’s coverage at InfoWorld.

You can also download the next version of the product and get many sample applications from their developer community site via

102.Visual WebGui (The .NET answer to Google’s GWT that extends WinForms over ASP.NET)

Visual WebGui (VWG) is an open source AJAX framework with a growing community that extends ASP.NET with the WinForms programming model.

VWG provides an alternative to ASP.NET’s page model in the form of WinForms forms and form events. Since VWG, like most .NET AJAX frameworks, is implemented using an IHttpHandler, it can still interact with ASP.NET pages enabling usage of VWG within an existing ASP.NET site.


xWire is a mature, object-oriented, enterprise-class toolkit that consists of both client (browser) and server (Java) editions. You can use either or both editions depending upon your environment. xWire was originally built back in 2001 and originally supported only IE5. Support has expanded to IE6, IE7 and Firefox. Opera support is coming soon. You can literally write enterprise-class AJAX applications that work in all of the supported browsers. We have lots of features that can be independently used as desired on both the client and the server. Additionally, COMET support is on the way.


WebORB is a platform for developing AJAX and Flash-based rich internet applications. The product is available for Java and .NET environments and includes a client side toolkit - Rich Client System to enable binding to server side objects (java, .net, web services, ejb, cold fusion), data paging and interactive messaging.


Zimbra is a recently released client/server open source email system. Buried deep within this product is an excellent Ajax Tool Kit component library (AjaxTK) written in Javascript. A fully featured demo of the product is available on, and showcases the extensive capabilities of their email client. A very large and comprehensive widget library as only avialable in commercial Ajax toolkits is now available to the open source community. Download the entire source tree to find the AJAX directory which includes example applications.


MochiKit, Prototype, Scripaculous and OpenRico wrapped up into one package for Plone, isolating web developers from writing and debugging JS.


Separate Structure (xhtml) from Behavior (javascript)


A Cross-browser JavaScript DHTML Library which adds Drag Drop functionality to layers and to any desired image


High Performance JavaScript Vector Graphics Library.

110.Nifty Corners

A small library for making rounded corners with Javascript.


Toxic is an AJAX toolkit, or framework, for creating rich web applications. It handles the tedious and repetetive tasks involved in integrating a client created using html and javascript with a server backend. It enables client side javascript to directly call class methods in PHP5 (or any other suitable language). It also enables the server side PHP to directly call client side javascript functions. Using Toxic you can get rid of much of the tedious work in form intensive rich web applications.


DOM-Drag is a lightweight, easy to use, dragging API for modern DHTML browsers.


AJFORM is a JavaScript toolkit which simply submits data from any given form in an HTML page, then sends the data to any specified JavaScript function. AJFORM degrades gracefully in every aspect. In other words, if the browser doesn’t support it, the data will be sent through the form as normal.

114.AJAXGear Toolkit

It is a toolkit that allows you to take advantage of the client-side technique known as AJAX. AJAX is shorthand for Asynchronous JavaScript and XML. It uses the XMLHttpRequest object to allow a Web browser to make asynchronous call to the Web server without the need to refresh the whole page.

115.Interactive Website Framework

A framework for creating highly interactive websites using javascript, css, xml, and html. Includes a custom xml parser for highly readable javascript. Essentially, all the plumbing for making AJAX-based websites, with js-based GUI toolkit.


jspkg is a package loader for Javascript, based on pluggable loaders for locating and loading scripts into a client-side Javascript application. It is designed to work best with unobtrusive Javascript libraries, but doesn’t impose any methodology or design on its users.


AjaxCaller is a thin XMLHttpRequest wrapper used in all the AjaxPatterns demos. The focus is on ease-of-use and full HTTP method support.


XOAD, formerly known as NAJAX, is a PHP based AJAX/XAP object oriented framework that allows you to create richer web applications.


What is the PAJAJ framework, it stands for (PHP Asynchronous Javascript and JSON). It is a object oriented Ajax framework written in PHP5 for development of event driven PHP web applications.


Provides PHP and JavaScript libraries for performing AJAX (Communication from JavaScript to your server without reloading the page)

121.Flexible AJA

Flexible Ajax is a handler to combine the remote scripting technology, also known as AJAX (Asynchronous Javascript and XML), with a php-based backend.


FlashObject is a small Javascript file used for embedding Macromedia Flash content.

123.OSFlash - Flashjs

The Flash JavaScript Integration Kit allows developers to get the best of the Flash and HTML worlds by enabling JavaScript to invoke ActionScript functions, and vice versa.


jWic is a java-based development framework for developing dynamic web applications with the convenience and familiarity of ‘rich client’ style programming. The component-based, event-driven programming model makes it easy for developers to quickly create flexible and robust web applications.


JSMX is an Ultra Lightweight - Language Agnostic - Ajax Framework. It is by far the easiest way to integrate Ajax into any Web Application. What separates JSMX from most other Ajax Frameworks is that the JSMX API runs entirely on the client and has no Server Side Components to install. Given this fact plus the fact that you can pass back JavaScript, XML, JSON, or WDDX makes JSMX a truly Universal Ajax API.

126.DreamFace Interactive

DreamFace Interactive, a member of the OpenAjax Alliance, provides a new way for Web-savvy business people to create, control, and share their own Web applications, through a concept called WebChannels, which makes it possible to create applications designed for change.

127. DOMAssistant

A completely modular lightweight JavaScript library.


JavaScriptMVC is a framework that brings methods to the madness of JavaScript development.

That’s all,enjoy!

From :