Rich Server Platform - User Interface

This proposal has been withdrawn.

Proposal for

Rich Server Platform – User Interface
Framework (RSP-UI)

This document declares the intent,
benefits and scope of a proposed project called "Rich Server
Platform – User Interface Framework" (RSP-UI). RSP-UI is
in the Project Proposal Phase as defined in the Eclipse Development
Process document. We propose that this project be established within
the Technology Project PMC.

Current status: We are currently working on the creation review slides.
Development is ongoing. New committers have recently joined the project
for a PDE Launcher and a "web.xml" extension point.

Introduction

Eclipse Rich Client Platform (Eclipse
RCP) has been successfully established as an application platform for
the client-side. With the recent acceptance of large parts of the
OSGi specification as a JSR (291), widespread application of OSGi for
server-side applications has become natural.

Recently, the Equinox Incubator has
begun applying the Eclipse/OSGi concepts to the server-side. This
opens tremendous new possibilities for Eclipse as an application
platform for the server-side (refer to
http://www.infonoia.com/en/content.jsp?d=inf.05.07) for a discussion
of possibilities.

The Eclipse/OSGi development model,
applied to the server-side, allows the creation of truly pluggable,
componentized, server-side applications. Plug-ins can communicate at
a logic layer with each other using established and tested methods,
such as extension points and OSGi services.

What is needed for the UI layer is a UI
composition framework which we propose in the form of RSP-UI.

First, RSP-UI will allow you to freely
combine the most suitable rendering technologies for versatile web
applications. Ideally, a web application based on RSP-UI should be
able to serve the user with a page that combines content from, for
example, a plug-in with XML/XSL transformation to display an RSS news
feed, a plug-in that uses PHP to render content, another plug-in that
uses JSF for rich interactive web components, and a plug-in that
renders LZX/Laszlo for interactive components with highest layout
requirements.

Second, RSP-UI will lower your entry
barrier to the respective advantages of the client- and the
server-side world, thereby augmenting the Eclipse community.

Furthermore, using RSP-UI, you will
increase code reuse, enjoy a flexible and lean assembly of just the
components and services you need, and enhance your productivity in
composing a versatile web application. RSP-UI adresses core needs in
the area of "service-oriented clients", where this
architecture allows developers to build better applications that are
more targeted to user needs, tasks, roles and workflows.

You find a demo walkthrough with sample
code of a basic server-side application at
http://www.infonoia.com/en/content.jsp?d=inf.05.09. It uses
jsp:include tags as the lowest degree of UI composition.

Issues, solution and benefits

Current Issues

Our solution

Your benefits

1. Code reuse between client-side and server-side is limited

Server-side UI framework that renders "dual"
components

You will increase code reuse

2. Modularizing server-side applications is difficult

Apply Eclipse/OSGi bundle paradigm to the server-side

You will enjoy a flexible and lean assembly of just the
components and services you need

3. Integrating UI from sets of rendering technologies is
cumbersome

Define (best practices) for UI interactions and composition

You will enhance developer productivity

4. Server-side world offers a large choice of rendering
technologies, but no single best answer as to which set to use
for web UI

Offer a large choice of rendering technologies to pick and
choose from

You will meet the diverse and special requirements of your
application efficiently

5. Client-side and server-side have developed in separate
worlds

Leverage familiar RCP paradigms and established web
technologies

You will enjoy facilitated entry to the advantages of "the
other" world

1. Code reuse between client-side
and server-side is limited – Many business-critical
applications have both a heavy data-entry element for internal use
(rich client) and a general-public web interface. Usually, the UI of
these will not be the same, however, good parts of the business logic
will be. By applying OSGi to the server-side, RSP-UI will provide you
with a web UI framework that allows you to reuse a lot of the
business logic (non-UI plug-ins) for both parts of an application.
With RSP-UI, you will be able to reuse "dual" components
that can be rendered both in a browser and in a rich client.

2. Modularizing server-side
applications is difficult – Many web applications have
numerous functional modules, such as shopping cart, news feed, or
user management. This compares to RCP applications where the Eclipse
IDE is also composed of numerous plug-ins. However, the WAR (Web
Archive) as the smallest deployment unit of aggregation in J2EE web
applications is too coarse grained to allow practical reuse of
application "modules". It is not practical to package each
module into its own WAR for numerous reasons, including the fact that
inter-WAR dependencies are not defined. However, maintaining multiple
modules inside a single WAR, with code, and URL resources usually
residing in different places, does not provide the degree of
isolation that makes such modules easily transferable and reusable in
other projects. RSP-UI will apply the OSGi bundle paradigm to the
server-side. So you will enjoy a flexible and lean assembly of just
the components and services you need to compose your application.

3. Integrating UI from sets of
rendering technologies is cumbersome – Eclipse/OSGi allows
inter-plug-in communication at the logic level via extension points
and OSGi services. Beyond the OSGi http-service as transport for http
resources, however, interactions at web UI level are not defined
today, making it cumbersome to "glue components together"
at the UI level. RSP-UI will focus on the definition of UI
interactions and UI composition in order to create a framework for
easily integrating UI from sets of rendering technologies and
frameworks already established in the server-side world. With RSP-UI,
you will enhance developer productivity

4. The server-side world offers a
large choice of rendering technologies, while there is no single best
answer as to which set to use for web UI – The choice will
vary with project requirements and developer skills, and may well
incorporate multiple approaches. Ideally, a truly componentized web
application is able to integrate and display content from plug-ins
that use classic web technologies such as, but not limited to,
JSP/JSTL, framework Struts/WebWork framework, Wicket, JSF/Facelets
and other applicable widget libraries, Spring and PHP. It should also
be able to integrate components that use rich rendering technologies
such as LZX/Laszlo.

A truly componentized web application
should be able to serve the user with a page that combines content
from, for example, a plug-in with XML/XSL transformation to display
an RSS news feed, a plug-in that uses PHP to render content, another
plug-in that uses JSF for rich interactive web components, and a
plug-in that renders LZX/Laszlo for interactive components with
highest layout requirements. RSP-UI will help you to meet the diverse
and special requirements of your application efficiently (and on a
macro level serve the "long tail", Carl Zetie, Forrester
Research).

5. Client-side and server-side have
developed in separate worlds – RSP-UI lowers entry barriers
for RCP developers to the advantages of server-side programming by
using familiar paradigms such as extension points, services, and
workbench API. RCP developers can thus benefit from the advantages of
server-side programming but don't need to learn the complete J2EE
toolsets. On the other hand, as RSP-UI offers integration facilities
with established web frameworks and rendering technologies, web
developers can leverage their experience with server-side
applications and thus efficiently develop rich server-side
applications. RSP-UI will facilitate your entry to the advantages of
"the other world" and thereby augment the Eclipse
community.

Making plug-ins run on a server
involves the whole application stack; RSP-UI makes no attempt to
cover the whole territory. Instead, it narrowly focuses on defining
interfaces and creating sample implementations for UI integration and
associated components.

The RCP workbench API will be analyzed
and used as the most structured, Java-based API for composing web UI,
and leveraged by templating and decoration. We also envisage
markup-based composition using a tag library that can be used from
JSPs.

Essentially, the same basic
abstractions of Eclipse UI will be used. Therefore, PageLayouts will
be defined by a combination of Parts. Different part types are
EditorPart and ViewPart. Parts will have their trim window built by
the workbench framework. This workbench will also provide features to
manipulate (maximize, minimize, restore, close, move and dock) views
and editors.

A given Part will be associated to
ContentProvider. Providers will be the link to different rendering
technologies, ranging from script languages such as PHP to
fine-grained widgets libraries.

Perspectives are a way to group views
for a particular purpose. Plug-ins can define new perspectives or
change perspectives defined by other plug-ins. The API used for a
plug-in to define a new perspective will be essentially the same as
Eclipse’s API. The developer will define an extension to the
perspectives extension point and implement the createInitialLayout()
method of a new IPerspectiveFactory implementation.

Likewise, the API for defining new
views are the same as Eclipse’s (through views extension
point).

The RSP-UI composition framework will
aim to ensure that individual rendering technologies can access a
shared context (such as request, session and application scope for
servlets).

The Apache Tiles framework is a very
popular server-side UI composition framework. Given its age of about
5 years, Tiles has limitations in its out-of the box capacities to
render non-JSP/servlet content. Some limitations are those of the
content to be integrated. For example, integration of JSF is
difficult given that JSF currently does not support page scope. Tiles
does not use the notion of workbench contributions, perspectives,
views and the like. We aim to resolve these issues in a "from-the
ground-up" construction of an extensible and configurable UI
composition framework which leverages the Eclipse/OSGi approaches.

We will design interfaces and sample
implementations that allow integrating classic web technologies and
frameworks in combined web UI. This will usually require an intricate
understanding of the workings of the particular technology and
framework implementation. Class-loading approaches of such frameworks
that differ from the OSGi model will be investigated and resolved to
meet OSGi requirements.

Taking PHP as an example, we plan to
take a uniform integration approach for scripting languages, with the
aim to allow the use of various scripting languages supported by JSR
223 (Scripting for the Java Platform Specification 1.1), such as, but
not limited to, Groovy. Scripting integrations will pass context
information through namespaces, as proposed in JSR-223.

2. Provide services commonly needed
for web applications

With project members coming from a
strong web applications background, part of the project effort will
be spent on features and services that developers have been able to
rely on in classic J2EE/J2SE web applications, and are useful to be
leveraged when writing Eclipse-OSGi server-side applications. These
features include, but are not limited to, runtime JSP compilation,
user authentication, servlet filters and listeners.

We will also address multiple
web-client specific issues, such as client state vs. server state,
user session state, "bookmarkable URLs", double-submit,
redirect after post, client-side validation, windowing, and
converting events from such web UI components into events/commands
that can be understood by RSP-UI and relayed to the applicable
integrated framework/component. Further integrations with WebWork
(Struts 2) and Tapestry are sought.

We consider leveraging time-tested
principles in established web module “composition”
frameworks such as Apache Tiles (Standalone) and SiteMesh to maximize
layout design and composition flexibility, and thus facilitate the
use of RSP-UI for any kind of dynamic web application, beyond a
specific workbench-style application. Note: actual use and
integration of Sitemesh would be subject to approval of modified
Apache license.

Deliverables

Plug-ins that allow composing UI
programmatically from multiple plug-ins that use any of the
following: JSP/JSTL, Apache Struts, Wicket, JSF/Facelets and other
applicable widget libraries, LZX/Laszlo and PHP. A
choice of APIs will be proposed, to include workbench-type web
applications, the most structured alternative will be closely
aligned with the RCP workbench API (perspectives, views, etc.)

A tag library plug-in that allows
doing the same declaratively

Sample "OSGi-fied"
implementations of the interfaces (where not delivered by the
original creator of the respective framework)

UI composition samples covering
the technologies/frameworks above

Basic build, run and deployment
support similar to and based on PDE and PDE Build

Basic remote bundle management
tool

Supporting server OSGi services as
needed

Documentation of the above

9 committers contribute to these
deliverables (see Organization for details).

Relationships with other Eclipse Projects

Corona (Tools Services Framework)
– The Corona project initiated by Compuware addresses needs for
remote components in a Service-Oriented Architecture (SOA) context.
It has no server-side UI elements. We have discussed touching points
with the Corona architects, and agree that its focus and concerns are
orthogonal. However, we have agreed a close collaboration so that
both projects may benefit by sharing server-side infrastructure
components. Should RSP-UI require remoting capabilities (not seen
today), we will attempt to avoid implementations that would conflict
with those of Corona.

ECF (Eclipse Communication
Framework) – Scott Lewis, ECF project lead, has expressed
interest to be a supporter of and possible committer to RSP-UI,
through RSP-UI usage and feedback by ECF. ECF is thus a potential
consumer of RSP-UI work.

Eclipse PHP-IDE – The
Eclipse PHP-IDE project focuses on tools to write PHP applications.
PHP-IDE can be used to build PHP components for RSP-UI.

Eclipse Platform – We have
engaged in discussions (with D. Pollock and C. Daly) with the intent
to use and integrate with the new and evolving Eclipse 3.2 command
framework to structure interactions and declaration of interactions
with the server, as is being introduced also to trigger commands from
the browser-based Eclipse help.

ECP (Enterprise Component Platform)
Proposal – ECP has been initiated by Exadel and focuses on
a business component framework that uses a JSF implementation for UI,
including markup. RSP-UI sees ECP as fully complementary as it nicely
fits with its integrating approach. Exadel and RSP-UI have agreed to
collaborate to maintain the complementary alignment of both projects.
RSP-UI and ECP see each other as integration points.

Equinox Incubator – There
is a very close collaboration established with Simon Kaegi, who is a
committer on the Equinox server-side incubator. Members of the RSP-UI
project consortium have previously tested, validated and provided
feedback to Equinox incubator work, notably the servlet bridge. If we
happen to create components that the Equinox incubator wishes to use
and feels are applicable beyond the scope of the RSP-UI project, we
will be most pleased to contribute them to their project.

IDE for Laszlo - We have made
contact with the IDE for Laszlo project architect aiming to ensure
that LZX/Laszlo components can be rendered within RSP-UI
applications. RSP-UI should support logic integration via Laszlo
extension points.

OHF (Open Healthcare Framework)
– We have discussed collaboration with OHF. OHF has server-side
requirements and wishes to be a consumer of RSP-UI work.

RAP (Rich Ajax Platform) Proposal
– RAP has been initiated by Innoopract and focuses on a non-JSF
widget implementation for UI that emulates SWT/JFace, in a Java-only
approach. First, RSP-UI aims to match the Java and web worlds by
contributing Java web expertise to the Eclipse community, and second
considers RAP to be one of multiple rendering alternatives which
would fit with the integrating approach of RSP-UI. RSP-UI can be used
for any kind of dynamic web application, beyond RCP workbench-type
applications. We had invited RAP to cooperate with RSP-UI, but while
discussing cooperation, they chose to independently submit their own
proposal. We respect their wish for an independent activity. We have
agreed to revisit merging activities in 6 to 9 months.

FAQ

Does RSP-UI depend on JSP or other
non-Java technologies?

No. A tag library is part of the
deliverables, but UI can be composed through Java code only, in an
API that will essentially be the same as the Workbench API. In web
applications, some URL resources, such as CSS and JavaScript always
use non-Java technologies.

Will my web application that uses
RSP-UI have dependencies on
JSP-JSTL/Struts/WebWork/Tapestry/Wicket/JSF/Facelets/Spring/PHP?

Not unless you choose so. The RSP-UI
project aims to allow you to use the rendering framework(s) of your
choice; though you will want to use at least one of them to render
content in Views and Editors if you want to run more than simple
servlets in your web application.

How does RSP-UI relate to Tiles and
SiteMesh?

Apache Tiles (Standalone) allows UI
composition of modules via XML templates, while OpenSymphony SiteMesh
is strong in combining and decorating arbitrary HTML streams. Both
functionalities are very useful in the context of all types of web
applications. Therefore, RSP-UI will build on their composition
concepts for Eclipse/OSGi-based web applications. Project committer
Cedric Dumoulin is the original creator of Tiles.

Will RSP-UI work with Spring?

RSP-UI invites contributions by the
Spring community to enable the use of Spring within RSP-UI
applications. Work is ongoing in the Spring community to provide use
of Spring with OSGi by Spring Release version 3.

Does RSP-UI enable my classic web
applications to run in RCP without any changes?

Running of arbitrary web applications
within RCP is already supported by the Tomcat plug-in, which is also
used by the Eclipse help system. RSP-UI may optionally explore
embedding RSP-UI-integrated components as individual UI contributions
within RCP applications. This might be done via the RCP Browser
widget and a pass-through bridge in an augmented version of the
Tomcat plug-in, which accesses the RCP application extension points.
WSRP (Web Services for Remote Portlets) concepts would be studied for
this. This item is optional since it may be too ambitious for this
project.

Will RSP-UI require a J2EE-certified
server or a Servlet Engine to run?

No. An initial implementation will use
the Equinox ServletBridge which runs in a servlet container as a
WAR-style application. This provides for maximum compatibility, as
this approach allows adding Eclipse-/OSGi components to existing web
applications, without having to migrate the entire web application to
Eclipse/OSGi. However, RSP-UI aims to be "server-agnostic";
it should be able to run in any OSGi-compliant environment. Given
that an OSGi-"server" can itself be composed with bundles,
and OSGi class-loading isolation features ensure that different
implementations of services can co-exist in the same OSGi
environment, as a general rule, RSP-UI does not depend on particular
OSGi container features beyond those specified by applicable OSGi
release levels.

Is the mission of RSP-UI to bridge
the gap between OSGi and all of JavaEE?

No. However, RSP certainly has the
potential to go beyond web applications, and include other parts of
JavaEE, such as Enterprise JavaBeans, applying the same benefits to
EARs as WARs. RSP-UI is aware of interest in running relevant JavaEE
features under OSGi, and time will tell in what form and by whom
those interests may be addressed. As more and more of the Java
development spectrum (JavaME-to-JavaEE) is brought into the modular,
extensible, RCP-style of definition and architecture, the longer
Java's lifespan will be. Should any questions of project scope arise
during the project, RSP-UI will act in accordance with the Eclipse
Development Process.

Will RSP-UI make web development
simpler?

We believe so. There is pent-up demand
for solutions that are simpler to implement than by playing the full
JavaEE orchestra. Wicket is one rendering technology approach that
helps for simplicity in UI development. The key theme of RSP-UI is
easy composition of smart technologies.

Is RSP-UI too ambitious? It sounds
ambitious.

Putting everything imaginable under the
heading of RSP into one project would be too ambitious. This is why
the RSP-UI project narrowly focuses on UI integrations, and provides
a framework, with sample implementations only, whereby
ContentProviders can use their technology of choice. It deals with
the complexity of the server-side world by providing uniform
integration approaches, in hindsight of and knowledge of existing
technologies. All project deliverables are assigned to definitive
committers.

RSP-UI does not intend to create a
server-side component framework beyond what Eclipse/OSGi already
provides. Further, RSP-UI applies existing concepts such as workbench
API as well as established server-side approaches. The RSP-UI project
aims to support a major strengh of the Eclipse platform: its capacity
for leveraging cross-technology integration.

Creating a UI composition framework
that integrates different URL resources is feasible; RSP-UI committer
Cedric Dumoulin has previously done this (Tiles). Running established
web frameworks under OSGi is feasible; RSP-UI committers from OPS4J
and Infonoia have done this. Composing web UI using Eclipse workbench
API paradigms is feasible; RSP-UI committers from Vetta Technologies
are doing this. Providing PDE build, run and deployment support is
feasible; RSP-UI committer Gunnar Wagenknecht has PDE experience.
RSP-UI brings these kinds of expertise together in a
multidisciplinary team for a successful project.

To avoid scope creep, we will be very
happy to spin off new, independent projects for scoped items that may
develop their own dimension, such as, but not limited to, scripting.
For example, it may be useful to extend scripting integration to
JavaScript, Groovy or Rails runtimes, within another project.

Does RSP-UI dilute Eclipse API?

No. By providing uniform integration
approaches, we actually help avoid API dilution. Uniform integration
approaches are very important when ContentProviders can use their
technology of choice. At the same time, RSP-UI follows the 2006
Eclipse Roadmap, which states that "Support for compiled
languages, scripting languages and "Java like" languages
such as JSP, SQLJ and the like are all related areas where work needs
to be done".

The more input the project receives,
the more cross-integration it can provide. We strongly encourage you
to contribute your ideas, vision, know-how and skills in an area that
may fall within the scope of this project.

Timing

June 2006: Eclipse 3.2/Callisto
release slated to already support deploying plug-ins to a servlet
container