ULC Technical Concepts
How does ULC work:
Designed for full-fledged desktop applications, Swing is the Java standard for high-end rich user interfaces. There is only one issue with conventional Swing-based clients: they do not fit into a Web architecture that runs all services on the server side except for the user interface. ULC resolves this issue by bridging the gap between Swing's user interface components and a Web architecture, thus enabling you to leverage advantages of both the client-side Java and server-side application management.
ULC Application Partitioning
As a developer, you use server-side proxy classes that offer the familiar API of Swing, e.g. ULCTable instead of JTable, ULCTree instead of JTree, etc. The library then takes care of the split between client and server, including object synchronization and communication. The application runs on the server, except for a client-side Presentation Engine that serves any number of applications, like a browser.
An application communicates with the Presentation Engine via any of the standard Java EE channels (HTTP or HTTPS), where the choice of protocol is merely a matter of configuration. Notice that ULC is a lean library that affects only the presentation layer of an application; for all other layers, the architecture is entirely open.
The entire state of the application is maintained on the server. The Presentation Engine displays the user interface and forwards user interactions to the server. Smart event handling, lazy loading and caching ensure that both client/server interaction and network traffic are optimized.
As a developer, you are relieved from the difficulties of distributed programming. You get 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 and Protocol Design Pattern (HOPP), where each Swing component on the client is complemented with a corresponding server-side component. In this way, you can use the ULC-enabled Swing components as if they were running on the server.
The Half Object and Protocol Design Pattern of ULC
The server-side model simplifies development. Built-in optimizations facilitate scalability and performance. A special development setup allows client/server applications to be run in stand-alone configurations, where both client and server are executing in the same Java Virtual Machine. This speeds up edit/compile/execute cycles, eases debugging and enables simulating various network conditions to mimic real-world runtime behaviour.
ULC's design allows for flexible deployment and integration:
Multiple options for deployment and integration are key benefits. ULC's API abstracts away from specific configurations and therefore results in applications that can be deployed in multiple scenarios without changing the code.
Leverage of Java EE / Java SE configurations offers better flexibility. In addition, ULC comes with a powerful extension API that allows the integration of virtually any third party library. ULC's code community offers numerous examples for custom widgets and third party integrations.
The Presentation Engine can be deployed either with Java Web Start or as an applet. Therefore, the UI of applications can be executed both within a browser or on the desktop. 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, or to access local devices like card readers.
Deployment Options on the Client-side
Applications are typically deployed on the server only. ULC is designed to fit into any Java EE compliant servlet container, i.e., an application can be deployed as a servlet. ULC also provides integration into JSR 168 compliant Portal Servers and hooks for integration into other application servers.
Deployment Options on the Server-side
Since client/server interaction is built-in, ULC can offer a setup that allows running applications in stand-alone configurations. In this setup, client/server interaction is simulated while the entire code executes within the same Java Virtual Machine.
Stand-alone deployment is useful for development and to realize applications that run both online and offline, relying on a single code base.