Skip to main content



The Scout project is a proposed open source project under the Eclipse Technology Project.

This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the Eclipse community. Please send all feedback to the Scout Eclipse Forum.


Business application developers face many recurring requirements. Implementing these should not require a significant amount of time. Instead, developers should be able to concentrate on understanding and implementing business cases.

The Scout framework substantially reduces development time for fully SOA and J2EE compliant solutions in the following areas:

  • Client Server Communication
  • Defining Interfaces for third party applications (server- and client-side)
  • Data binding
  • Implementing and layouting screens
  • Support of a common CICD (Corporate Identity Corporate Design)
In addition, architecture driven issues are addressed:
  • Integration of existing applications
  • Support of SOA and usage of services
  • Ensure a common architecture over a company's application landscape
  • Facilitate the exchange of developers across different projects


This proposal covers two main parts: Scout and Scout SDK, both are realized as fully compliant Eclipse plugin set. An overview of the application building process with the Scout framework is provided below. For more detailed information also see our Scout wiki.

Scout provides an application model, a reference implementations, and utilities proven to be useful for business application development. Main aspects included in Scout are listed below:

  • Scout application model supporting a clear and simple definition of business applications.
  • Abstract UI component model including implementations for its Swing and SWT/JFace representations.
  • Exchangeable client server communication. A reference implementation using the HTTP(S) protocol.
  • Remote service infrastructure. Calls to services do not assume a specific location (client or server).
  • Client notification for communication from the server to the clients
  • Support for integrating 3rd party libraries and applications

The Scout SDK provides the tooling to build/manage applications based on Scout. This is achieved by generating pure Java code. Main aspects included in Scout SDK are listed below:

  • Wizard support for managing the Scout application model.
  • Real time synchronization of the application model and the generated Java application code.
  • Tooling for providing/consuming web services, implementation of application services, and multi-language support.
  • Build and launch support for Scout applications.

Out of scope for this proposal:

  • Scout does not provide a persistence layer. The Scout data transfer objects (DTOs) represent the link to a percistence layer.
  • Scout is not a GUI builder. The Scout client manages the mapping from the application model to a specific UI implementation depending on the UI plugin representation that is shipped with the application.

Outlook e4

Several concepts from Eclipse e4 are already integrated in the Scout framework such as a fully OSGi service oriented architecture (no singletons) and the usage of a UI independ application model (analog to the e4's IPresentationEngine concept).

The Scout application model will become an extension of the e4 workbench model and include the UI component layer (e.g. SmartField, TextField, TableField, …). Based on e4 and Scout users may create complete and sound application models (EMF).



Scout is the base of applications that may be developed with or without the Scout SDK. Scout applications are built on top of the Scout runtime layer. Maintenance of such applications and maintenance of the Scout runtime layer is only loosely coupled as illustrated in the diagram above.

As Scout is written in pure Java/J2EE and satisfies the OSGi paradigm, integration of 3rd party libraries or applications is fully supported. The Scout runtime both provides a large amount of reusable functionality and a library of abstract UI component models.

The extension point registry is reused to define Scouts extension points. An Eclipse compliant extension point defines the UI representation of every component model. This simplifies adding and changing of specific component representations as well as the application representation. With a Swing and a SWT/JFace representation Scout already provides two UI implementations.

Functionality overview:

Topic Description
Architecture Sound and correct SOA architecture. Client- and server-side SOA.
Communication Exchangeable communication layer with a HTTP(S) implementation.
Services J2EE session safe service registries and the ability to remote a service. Service calls look equal on both client and server side.
Internationalization Multi language support, number, date and currency formats.
Components Approx. 35 main UI components cover most requirements of real live business applications. Both Swing and SWT/JFace representations are available.
Session Context Enables J2EE backend session handling.
Client Notification Inverse communication (from server to client).
Extensions The ability to extend the framework in functionality and behaviour through the Eclipse extension mechanism.

Scout SDK

Scout SDK is an Eclipse plugin set that boosts developer productivity in building complete applications. Examples of such applications are:
  • Standalone rich client platforms (Equinox, SWT/Swing)
  • SOA/ESB node consisting of J2EE with service registry and web services (Equinox)
  • Rich client platforms with a J2EE Backend (Equinox, SWT/Swing)
Scout SDK operates on top of both the Eclipse JDT/PDE model. Scout SDK guides the developer in building Scout based SOA compliant applications. Instead of implementing the same patterns of an application again and again, Scout SDK helps to reduce development time by offering tooling and outline views to navigate the application. As a consequence, developers can focus their work on the business logic of the application. In the background Scout SDK takes care of the sound architecture and complete structure of the Java project.

The result of a solution developed with Scout SDK is a pure Java solution consisting of one or more Equinox/Eclipse based applications.

Functionality overview:

Topic Description
Application Model Wizard support to add/remove/modify the application model. Drag and drop support.
Template Support Reuse enriched components. Create a template of forms.
Internationalization Editor to browse, create, and edit multilingual application texts.
Extensions The ability to extend Scout SDK to manage new components or add new SDK functionality on existing components.
Build and Launch Support to export the application and launch both server and client in the context of the SDK.

Relationship with other Eclipse Projects

Scout applications are pure OSGi based Java/J2EE project. Therefore, any Eclipse project may be reused in Scout applications. Eclipse projects with a significant dependency to this proposal are listed below.

Project Description Impact
PDE The Plug-in Development Environment provides tools to build Eclipse plug-ins, fragments, features, update sites and RCP products. Scout SDK strongly depends on PDE and uses functionality provided by PDE including the plugin model.
JDT The Java Development Tools project provides the tool plug-ins that implement a Java IDE supporting the development of any Java application, including Eclipse plug-ins. Scout SDK strongly depends on JDT and uses functionality provided by JDT such as the type and compilation unit abstraction.
Equinox The Equinox project represents a first class OSGi community and fosters the vision of Eclipse as a landscape of bundles. Scout applications are fully OSGi compliant. The Equinox implementation is used on both the client and the server side.
BIRT Business Intelligence and Reporting Tools is an Eclipse-based reporting system for web applications. Scout SDK support for BIRT is scheduled. Currently, BIRT functionality may be integrated in Scout applications without Scout SDK tooling support.
Riena The Riena platform provides a foundation for building multi-tier enterprise client/server applications. Riena and Scout have evaluated their impact to each other. A friendly co-existence is intended and a common interest in the development of components useful to both projects has been identified.
ECF Eclipse Communication Framework. Supports the development of distributed Eclipse-based tools and applications. The Scout project evaluates the ECF project to use as a communication framework.
RAP Rich Ajax Platform. The RAP project enables developers to build rich, Ajax-enabled Web applications. Scout SDK RAP support is scheduled. Currently, a demo Scout application that uses RAP is available.
Swordfish Swordfish provides an extensible SOA framework based on the proven Eclipse Equinox runtime technology. The Scout project is evaluating Swordfish to orchestrate business process on the BEPL standard.
EclipseLink The Eclipse Persistence Services Project (EclipseLink) provides a complete persistence framework that is both comprehensive and universal Scout project is evaluating to integrate EclipseLink as a standard persistence layer. Today EclipseLink and others are and can be used as a persistence layer. Currently, Scout SDK provides no tooling for the persistence layer.
EMF The Eclipse Modeling Framework project supports modeling and code generation for building tools and other applications based on a structured data model. Starting with e4, the Scout application model will become an extension of the e4 workbench model.

Legal Issues

Apart from dependencies to existing Eclipse plugins, the initial code contribution from BSI AG relies on the availability of the following libraries. As part of the code contribution review, BSI AG will also submit these for approval per the Eclipse development process.

Plugin External Part Licence
javax.mail All Sun Java
javax.mail.fragment.jre1_5 All Sun Java
javax.mail.fragment.jre1_6 All Sun Java
org.eclipse.scout.sdk.ant Apache Ant Apache Licence 2.0

Committers and Project Lead

The following individuals are proposed as initial committers to the project:

  • Matthias Zimmermann, Co-Lead (BSI AG)
  • Andreas Hoegger, Co-Lead, Committer (BSI AG)
  • Ivan Motsch, Committer (BSI AG)
  • Hannes Müller, Committer (BSI AG)
  • Stephan Leicht, Committer (BSI AG)

Initial Contributions

Functionality described in this proposal will be provided by BSI AG. The Community is asked for input on the existing code base, feature requests for new functionality, and bug requests.


The following Architecture Council members will mentor this project:

  • Jochen Krause, Innoopract
  • Markus Knauer, Innoopract
  • Thomas Schindl,

Interested Parties

The following companies have expressed interest in this project:

  • compeople
  • EclipseSource
  • Weigle Wilczek
  • Schlag & Rahm

The following individuals have expressed interest in this project:

  • Aleksey V. Zapparov
  • Gilles Iachelini, CSC
  • Benjamin Muskalla, EclipseSource
  • Frank Gerhardt, Gerhardt Informatics Kft.
  • Michael Pucher, affinis
  • Tonny Madsen, The RCP Company
  • Ricco Deutscher, Sopera

Project Scheduling

  1. February-2010: Scout proposal under
  2. March-2010: Provisional code in Eclipse repository
  3. Mai-2010: Scout project status, code in Eclipse repository
  4. 2011: Scout as a formal part of the Eclipse release train

Changes to this Document

Date Change
30-March-2010 Updated list of interested parties
18-March-2010 Updated comments regarding Riena and list of interested parties
08-February-2010 Updated according to comments from Wayne Beaton
03-February-2010 Updated according to comments from Markus Knauer and Tom Schindl
21-January-2010 Updated according to comments from Wayne Beaton
07-January-2010 Updated according to comments from Tom Schindl, and Jochen Krause
05-January-2010 Document created

Back to the top