Canoo UltraLightClient 6.0 (Snippet ID 23546)

Canoo Engineering AG

UltraLightClient is a library to build Rich Internet Applications (RIA) in Java. Using this standard Java library, developers achieve unprecedented productivity in providing rich, responsive graphical user interfaces (GUIs) for enterprise web applications within J2EE and J2SE infrastructures.

Based on open standards, ULC easily integrates with any J2EE software. It provides developers with a homogeneous environment and speeds up both development and deployment of client/server applications.

The core idea of ULC is to run applications on a centrally controlled application server, like HTML based applications. Only an application-independent Presentation Engine runs on the desktop.

The Presentation Engine displays the user interface and forwards user interactions to the server. The entire state of the application is maintained on the server. The Presentation Engine is conceptually stateless but caches state for immediate access to increase performance.

An application communicates with the Presentation Engine via any of the standard J2EE channels (HTTP, HTTPS, or RMI / IIOP). The choice of protocol is merely a matter of configuration.
Since the Presentation Engine is application-independent, it can be used for any number of ULC based applications, in the same way as a browser can be used for any number of HTML based applications. There is no need for application-specific administration of desktop machines.

The Presentation Engine is approximately 500 KB of Java code, and it is all that needs to be deployed on the desktop to execute ULC based applications. This means that the client deployment effort is independent of the number of applications as well as their size and complexity.

Application Development
The application developer is shielded from all distributed programming aspects by the ULC library. From the developer's perspective, a ULC based application is developed and run entirely on the server side, i.e. there is a seamless server-side programming and runtime model.

How does this work? - ULC extends the capabilities of Swing by using the state-of-the-art half object design pattern, where each Swing component on the client is complemented with a corresponding server-side component. In this way, the developer can use the ULC enabled Swing components as if they were running on the server.
Specifically, developers are provided with a ULC widget set that is based 1:1 on the Swing widget set. Developers can use these ULC widgets like Swing widgets, while the ULC half object design pattern takes care of the split between the client side and the server side.
Given this simple and effective design, programming of scalable server-based applications becomes easy: there is no need to take care of the difficult split between client and server, which is a tremendous bonus for time to market and quality.

A further benefit of this design is that it enables an efficient setup for development: a special development mode allows running client / server applications in standalone configurations, where client and server are running in the same Java Virtual Machine. This speeds up compile/execute cycles, eases debugging and allows the developer to set up "goodies" like the simulation of various network conditions to mimic real-world runtime behavior.

Deployment and Integration
Compared to the deployment of ordinary Java based client software, ULC provides the advantage that the client-side Presentation Engine has to be deployed only once for any number of applications. The Presentation Engine can be deployed using the standard deployment mechanisms for Java based clients, namely Java Web Start, applets, or standalone installations. Being a 100% pure Java program, the Presentation Engine can be configured and adapted to fit into existing client-side infrastructures (e.g., to comply with security standards).

The code for ULC based applications is deployed only on the server side. ULC is designed to fit seamlessly into any J2EE compliant Servlet or EJB container, i.e., an application can be deployed as a Servlet or as a stateful session bean. In addition, ULC provides hooks for integration into other application servers.
At runtime, the Presentation Engine is instructed to connect to a specific application. After connecting, it receives a description of the application's initial user interface and displays it. After that, user events are forwarded to the application on the server side (low-level events being handled locally or converted to higher-level events), which will update the user interface if required.

Features:
Server-side programming model:
Develop scalable web applications for thousands of users as simply as stand-alone Swing applications.

Features

- Superior security:
No application code is executed on the client, nothing is stored in a browser cache.

- Application deployment on server:
A lean Java presentation engine on the client serves any number of applications.

- Pure Java library:
Use your favorite IDE and get add-on tools for visual editing, client/server simulation, and load/performance testing.

- No runtime licenses:
Deploy your ULC application on any number of servers and for any number of users for free.

Software Requirements
Requires Java 2 (JDK 1.3 or later) on server and client.

Product Web Site:
http://www.canoo.com/ulc/

White Paper:
http://www.canoo.com/ulc/home/whitepaper.html

Getting Started with UltraLightClient:
http://www.canoo.com/ulc/developerzone/gettingstarted.html

Canoo UltraLightClient 6.0 home page