Review: Canoo ULC 5.1
by: Drew Falkman
Summary
Canoo Ultra Light Client (ULC) is a new paradigm for developing
network-enabled rich client applications. This new breed of
application looks to replace the request-response HTTP/HTML
model that has predominated the enterprise and Web application
arena since the advent of the Internet. Rich clients
applications are looking to add further power to the client side
of applications, thus easing server load and significantly
enhancing the user experience. More
Information
Introduction
ULC is a Java library to speed up and ease the process of
developing enterprise and Web applications that utilize rich
clients, clients that contain interactive components, such as
drop-downs, trees and tables. In short, the componentry many of
us have become accustomed to in desktop application, only these
rich clients will have ties into a centralized server-based
application. The intended result is an application that allows
user to spend less time performing tasks, that eases network
traffic by eliminating the necessity of sending entire
"pages" to and from the server for every interaction
and that allows for increased utilization of the client system.
The Case for J2EE Rich Clients
Since the advent of Web and enterprise applications, the
standard client has been the HTML interface. This client has
seen all of the updates to the HTML specification(s) and
undergone proprietary extensions and new scripting technologies
but at the end of the day, it is still a fairly "dumb" client.
Input is generally gathered using HTML forms pages, and that
vast majority of processing is done on the server side. This
architecture requires a vast amount of server power as each
request is processed and a new UI is returned to the client.
Additionally, other than basic style, HTML forms are monolithic,
far from the rich component models offered in traditional
desktop applications. The result is that users are forced to
interact with enterprise/Web applications in an archaic
request/response manner, with little happening other than data
entry and static responses on the client side.
An example rich client interface.
A number of J2EE-accessible technologies have tried to address
this issue: JSP, JavaServer Faces, XForms and more. Ultimately,
the only processing power required of the client machine is to
render pages -- the server still does most of the work and
little is changed in terms of creating a richer user experience.
Not to mention that scripting technologies are browser-specific,
and, when used, often require significant additional work to
perform simple tasks such as data validation.
Enter the rich client. A rich client allows for more efficient
use of the client machine. By using interactive components,
enterprise and Web applications can behave more like desktop
applications. Data can be sent to/from the server without having
to reload the entire interface. Logic and data storage can be
implemented on the client side. A more natural management of
state is attainable. The server can focus attention on business
logic and data handling and not UI generation. The developer's
world is a better place while the end-users' experience is
significantly enhanced.
While rich clients would have been desirable in Internet
application development from the beginning, a few new
revelations have made the prospect possible:
- The advent of Web Services (and service-oriented
architecture, SOA) enables remote access to functionality across
networks and platforms.
- The advent of the Internet computer - dumb terminals - never
happened. The vast majority of Internet users are using powerful
machines with loads of memory and fast processing power.
- Messaging technologies have advanced greatly allowing for
better interaction--both synchronous and asynchronous--between
systems across a network.
- XML
- Web/enterprise applications have evolved to become
complex entities.
- Overall, Internet technology has greatly matured.
Even with these innovations, rich clients are slow to take hold.
This is primarily because a lack of standards in this arena and
a lack, quite frankly, of quality contenders. Until recently,
there were few options and those that existed had core flaws.
Proprietary DHTML implementations had browser issues and took
too long to code, Java applets have JVM requirements and other
issues. Other clients require browser plug-ins and usually have
their own proprietary programming paradigm that does not fit
with J2EE application development and deployment. But this
starting to change as new contenders enter the arena and old
contenders freshen up their offerings to capitalize on new
technologies and new requirements.
Important Rich Client Features
As the options for rich clients grow, it is important to
understand just what makes a good rich client technology. Some
of the more important items include:
- Simple and familiar development environment
- Simple and familiar UI design environment
- Simple and familiar deployment paradigm
- Familiar scripting language
- Interaction with desktop applications
- Component-based architecture
- Web Services enabled
- Can call on J2EE components: JavaBeans, servlets, EJBs
When reviewing ULC, I wanted to determine if it met all these
requirements. To get started, let's take a look at how ULC takes
on the concept of rich clients.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
|
