Advantages vs. Eclipse RCP

Three key advantages of ULC applications vis-a-vis Eclipse RCP applications:

ULC serves a different purpose than Eclipse RCP. While Eclipse RCP is a large platform for client-side productivity applications, ULC is lean library that enables using Swing in a server-side web architecture.

ULC compared to Eclipse RCP

Diagram comparing architectures of ULC and Eclipse RCP

No Application Deployment on Client

ULC applications are deployed on the server. The UI is executed by a Presentation Engine that needs nothing beyond a standard JRE on the client:

Application Deployment on Client

Eclipse RCP applications are deployed on the client. Moreover, they need a client-side installation of SWT and Eclipse RCP in addition to a standard JRE:

  • the Presentation Engine serves any number of applications, like a browser.
  • each application requires a client-side deployment.
  • the size of the Presentation Engine is small.
  • the size of the client-side deployment is large.
  • the Presentation Engine supports multiple JRE releases. It works out-of-the-box on many clients, because most clients have some version of Java installed today, either as a browser plug-in, or on the desktop.
  • client applications typically require specific releases of Eclipse RCP, which in turn require specific JRE releases. This double dependency means that Eclipse RCP applications require a complex installation on the client.
As a result, the Presentation Engine can be easily downloaded and executed as an applet at runtime. Likewise, its deployment with Java Web Start or other mechanisms is substantially simplified. Due to these three characteristics, client deployment as an Applet is virtually impossible. Likewise, distribution with Java Web Start or other mechanisms is difficult and virtually impossible in heterogeneous environments.

Scalable Server-side Architecture

Both the programming model and the execution model of ULC are server-side. Applications are installed and executed on the server. The client executes a compiled Presentation Engine that is independent of individual applications. As a consequence,

Client-side or Distributed Architecture

Eclipse RCP applications have a client-side or distributed programming model and execution model. The code for the rich UI executes on the client, possibly together with business logic. As a consequence,

  • the developer is alleviated from the difficult issue of distributing logic between client and server.
  • the developer has to distribute logic between client and server, which is expensive and error-prone.
  • applications are easy to scale up for thousands of users, because
    - client/server interaction is built-in and highly optimized, and
    - standard Java EE is supported out of the box.
  • applications are often difficult to scale up, because
    - client/server interaction has to be optimized for each application, and
    - server-side scaling options must be evaluated for each application.
  • applications are easy to protect against security attacks, because the client executes the Presentation Engine only.
  • applications are difficult to protect against security attacks, because the architecture allows executing any kind of code on the client.
  • applications can share the entire software platform with HTML applications and are easy to integrate with HTML applications.
  • applications need their own software platform and are difficult to integrate with HTML applications.

Lean Code

ULC is a library with lean code. Essentially, ULC provides a server-side API for the standard Swing components: it bridges the gap between client and server, enabling developers to use the Swing components in a server-side JEE architecture. The consequence is that:

Millions of Lines of Code

Eclipse RCP is a large software platform that is based on millions of lines of code. It includes several complex frameworks and a deep software stack, offering a comprehensive infrastructure and highly sophisticated components for client-oriented productivity applications. The consequence is that:

  • ULC is a good option for server-oriented applications. ULC’s lean software stack provides exactly what this type of application needs: an efficient user experience for the server-side business functions.
  • Eclipse RCP is a poor option for server-oriented applications. Its deep software stack and vast functionality is an overkill for this type of application, because it offers client-side infrastructure that is not needed.
  • ULC’s code is concise and maintained by a single team. As a consequence, ULC’s source code is simple to understand and has a uniform level of quality.
  • Eclipse RCP’s code is expansive and maintained by a multitude of teams. As a consequence, Eclipse RCP’s source code is difficult to understand and has a heterogeneous level of quality.
  • ULC has several orders of magnitude fewer bugs than Eclipse RCP.
  • Eclipse RCP has several orders of magnitude more bugs than ULC.