Introducing Open SUIT

What is it ?

SUIT stands for Simple UI Toolkit.

So, basically, it's a simple, open source, presentation framework for J2EE applications !

Why another new presentation framework ?

Indeed, there are already thousands.

Actually Open SUIT does not try compete on the same category as other presentation frameworks.

It intentionally withdraws from the technological and fanciness race, and focuses on quality and productivity.

Thus, the GUI development costs generally observed in projects using Open SUIT drops below 10%. No kidding.

A bit of history

The concept of this framework was first designed for developing the France Telecom Video On Demand portal.

Development costs and defect rate were tremendously reduced.

It was then generalized to cover a more general purpose: developing Web Applications.


Open SUIT requires:

  • Servlet API 2.0 or higher,
  • Apache Commons Logging,
  • Java 5 or higher.

It may be used in any J2EE server.


These are the main Open SUIT features

Declarative approach

The application user interface is declared in XML (partly or fully).

Open SUIT relies on a powerful XML binding framework, taking in charge:

  • object model instantiation (from XML to Java),
  • object model serialization (from Java to XML),
  • XML schema (XSD) generation.

Component oriented

The framework and its extensions provides a set of atomic components that you can put altogether to build your application.

Build-time validation

The GUI object model is able to validate itself at any time.

This is a built-time feature, this means you'll be able to detect problems at the earlier stage in your development process (even before running the application).

URL abstraction

During the GUIs authoring, you never manipulate URLs directly, but instead high level functional notions (such as « show page ABC », « ask for a confirmation », « invoke this method then display this page », …)

URL consistency

At any time, the URL in your web browser address bar is consistent.

In other words it always contains enough information to restore the original application context (page, data, ...).

This brings for free support of back & reload and the ability to bookmark and exchange any URL from your application.

Fine-grained lifecycle management

Open SUIT provides an automatic management of your beans lifecycle (when do the beans have to be initialized ? when can they be dropped ?)

For this, it introduces the notion of page context, a life scope between the standard request and session, that corresponds to the lifescope of an interactive process.

This allows to minimize efficiently the global footprint of your application sessions.

Compiled Expression Language

Open SUIT embeds an expression language engine with a grammar fully compatible with the Unified Expression Language.

The major difference is that expressions are compiled and strongly typed.

This is a strong choice made for quality (compilation is build-time), and performance (no expression parsing nor introspection at runtime).

Error management

Open SUIT provides a simple and efficient way of managing application exceptions:

  • how to bring them to the end user,
  • how to display them with all required information in the user's language,
  • how to let the user react in the appropriate way.

It is also very easy to override the standard behavior.

Addresses standard functional needs

Unlike other presentation frameworks, Open SUIT provides high level components that respond to very common functional needs.

Thus you'll be able - for instance - to display an ask box or an acknowledgment message to the end user in the middle of some interactive process, without having to (re)develop that kind of page.

Forms validation

Open SUIT provides several generic form field validators.

It also provides two simple mechanisms to handle partial or full validation in your code.

No big deal, but it had to be mentioned...

Overridable and extensible

It's possible to override the core Open SUIT components behavior.

It's also possible to extend the base Open SUIT components with your own extension library, and to reuse it in any application.

In standard, Open SUIT comes with two extensions (in addition to the base components):

  • spring (to integrate Spring),
  • and charts (to integrate JFreeChart).


Open SUIT can perfectly coexist with Struts, JSF, JSP or any other J2EE technology in the same application.

Enforces W3C Standards

The HTML code produced by Open SUIT validates (4.01 Transitional) and is highly accessible.

This implies no development effort.


Here are the reasons why the main Open SUIT keywords are quality and productivity.

Build-time validation + Eclipse plugin

Build-time validation is really the main argument for ensuring quality. It will let you know about problems much earlier than with other presentation frameworks.

The Eclipse plugin simply leverages this feature by triggering validation automatically during the development process, with a tight integration within Eclipse (each issue being logged in the « Problems » view with a comprehensive message).

Strong reuse

The component approach allows to develop a component once and reuse as-is everywhere in the application.

Takes care of technical stuff

The presentation layer involves quite vast and complex technologies and specifications:

  • HTML
  • CSS
  • HTTP (get/post)
  • JavaScript
  • accessibility

Moreover there are some complex issues related to those technologies. For instance :

  • encoding (not only the page but also url parameters, and even decoding the GET and POST requests),
  • web browser specificities,
  • support of back & reload
  • good use of redirect
  • implementing valid ergonomics patterns
  • ...

Assuming every single developer is able to cope with all those technologies and issues is a nonsense.

That's why the Open SUIT approach is - instead of letting the developer cope with those - to embed all this know-how once and for all into the presentation framework.

RAD (Rapid Application Development)

The framework provides a set of basic components that allows building up an application very quickly.

On top of that, XML authoring strongly relies on XSD (XML Schema), which enhances incredibly your efficiency (inline documentation, auto-completion and content-assist).

Behavior homogeneity across applications

Applications developed with Open SUIT share the same ergonomics patterns.

In other words they look pretty much the same in the way they behave... even if they were not developed by the same people!

Reduced memory consumption

Open SUIT provides a clever automated bean life cycle management that keeps the sessions memory footprint very low.

Getting started

Enough talking, let's start.