Comparisons

wingS is one of numerous frameworks aiming to abstract from the difficulties web application developers are facing, like the page-oriented paradigm of the web and the multitude of technologies needed. This page serves to compare wingS to some of its more well-known alternatives, and to outline its advantages. You can learn more about adjustable beds with wings on our homepage. The information on this page is translated from the diploma thesis by Stephan Schuster

JavaServer Faces

JavaServer Faces (JSF) is a popular standard for server-side web GUI frameworks based on Java. Its primary goal is, according to its specification, to the simple creation of web applications based on reusable components. Just like wings, JSF uses the MVC pattern, though in a somewhat different way: the model is constructed from JavaBeans. Usually used as a view is a Java Server Page (JSP), which is a HTML page enriched with JavaScript. It contains the individual components in the form of special tags, whose functionality is located in Tag Libraries. The controller is represented as a central servlet which receives all requests and initiates the appropriate processing. Which view is called when is configured through navigation rules in a central XML file. Though JSF promises reusable components as well as a clear separation of presentation and logic, it shows several disadvantages compared to wingS: while the latter enjoys the benefits from complete object orientation, JSF is conceptually stuck in the pages-and-requests paradigm. Through its error-prone mix of various technologies (Java logic, JSP pages, Tag Libraries, XML navigation, HTML presentation), it implies a complex development that in many places ignores even the most basic object-oriented principles. For example inheritance, refactoring of the presentation logic and test-driven design approaches are not possible without the use of additional auxiliary means.

Echo2

Echo2 was developed by NextApp and is a server-sided Ajax-Framework for the creation of component-oriented and event-driven web applications. It is advertised as a solution that requires no knowledge about technologies like HTTP, HTML, JavaScript or CSS ‚€“ at least unless the set of existing components shall be extended. Therefore, in most cases development work is done exclusively in Java. The framework achieves the implementation of the Ajax-concept through an architecture consisting of several separate modules. Its Application Framework provides the interface for application programming (API) through which the UI is constructed and the state of the application is managed. The complete functionality needed for the visual representation of the components and for the data exchange with the client is encapsulated in a self-sustaining module called Web Rendering Engine. The so-called Update Manager serves as an intermediary between those two. It tracks the changes in the UI‚€™s component model and presents them to the Web Rendering Engine for further computations. Additionally, it receives their inputs and distributes them to the affected components, where they are processed appropriately. Due to the underlying client-server-architecture, the Web Rendering Architecture consists of two parts: the Server Engine and the Client Engine. The former is based on the Java Servlet Technology and is responsible for the handling of client requests. The latter runs as a complete JavaScript module in the user‚€™s web browser and this way provides the remote web GUI for the server-sided application. Its main task consists of the synchronization of the state of client and server. For this purpose, the client transmits all significant user input through the massive use of XMLHttpRequests back to the server. Echo2 uses the XML format for the exchange of data. Changes of the client‚€™s state are hereby encoded in special tags which contain both the explicit kind of the modification and the identifier of the affected component. The server computes the received message and updates the component model. In this process, events, which may imply additional changes of state, are fired and distributed to the interested listeners. Once the computation is completed, the server sends a similarly structured XML message back to the client. It contains all instructions needed by the client for the incremental update of the web GUI via DOM.

Google Web Toolkit

The Google Web Toolkit (GWT) is an Ajax-Framework whose implementation follows completely new approaches. Just like wings and Echo2, GWT allows the development of web-GUIs after the model of Swing, and includes a library of readily usable components. What distinguishes the framework from any other one is the way the client-side surface is implemented. Instead of holding the component model on the server and informing the client of all changes of state, GWT compiles all visual components written in Java to JavaScript code. Due to this, the application behaves in the so-called Hosted Mode at development time just as it does in the later Web Mode at runtime inside the browser. To be able to guarantee the same functionality, the developer has to construct his or her components based on Google‚€™s JRE Emulation Library, a subset of the Java 1.4 API. The completed application is then run on a small, generic client engine. Requests to the server only occur when raw data has to be loaded. For this, GWT provides asynchronous Remote Procedure Calls (RPC) and serialization mechanisms that allow for the requesting of server-sided Services (no Web Services) in the form of Java objects.

Backbase

Backbase is being developed by the like-named company and claims to be the leading Ajax-Framework in the corporate environment. The central component of its architecture is the Backbase Presentation Client (BPC) which is written in Java and serves as a runtime environment within the web browser. The BPC is programmable through the Backbase eXtensible Markup Language (BXML) a declarative description language for graphical user interfaces. It contains various visual components, a mechanism for assigning them specific actions as well as means for the asynchronous communication with the server. On the later, the Backbase JSF Runtime can be used which shall enrich the page-oriented paradigm of the JavaServer Faces (see above) with Ajax functionality. This not quite trivial task is solved through an additional server-sided set of visual components from whose components the developer can construct the UI. The framework handles the mapping of each server-sided component to its client-sided BXML pendant. It likewise tracks the changes of state in both component trees and handles the necessary synchronization.