Eclipse UML2
2.0 Plan

Last revised 15:50 EDT June 08, 2006 ( marks interesting changes over the previous plan revision)

    Please send comments about this plan to the developer mailing list.

This document lays out the feature and API set for the next feature release of the Eclipse UML2 project after 1.x, designated release 2.0.

Plans do not materialize out of nowhere, nor are they entirely static. To ensure the planning process is transparent and open to the entire Eclipse community, plans are posted in an embryonic form and then revised from time to time throughout the release cycle.

The first part of the plan deals with the important matters of release deliverables, release milestones, target operating environments, and release-to-release compatibility. These are all things that need to be clear for any release, even if no features were to change. 

The remainder of the plan consists of plan items for the projects under the Eclipse UML2 project. Each plan item covers a feature or API that is to be added, or some aspect that is to be improved. Each plan item has its own entry in the Eclipse bugzilla database, with a title and a concise summary (usually a single paragraph) that explains the work item at a suitably high enough level so that everyone can readily understand what the work item is without having to understand the nitty-gritty detail.

Not all plan items represent the same amount of work; some may be quite large, others, quite small. Some plan items may involve work that is localized to a single subsystem; others may involve coordinated changes across several projects within the same top-level project; and others may involve coordination with other top-level projects. Although some plan items are for work that is more pressing that others, the plan items appear in no particular order.

With the previous release as the starting point, this is the plan for how we will enhance and improve it. Fixing bugs, improving test coverage, documentation, examples, performance tuning, usability, etc. are considered routine ongoing maintenance activities and are not included in this plan unless they would also involve a significant change to the API or feature set, or involve a significant amount of work. The intent of the plan is to account for all interesting feature work.

Release deliverables

The release deliverables are:

  • Source code release for Eclipse UML2, available as versions tagged "R2_0" in the CVS repository.
  • UML2 runtime binary and SDK distributions (downloadable).
  • UML2 runtime binary and SDK features on update site (install via Eclipse update manager).

Release milestones

Release milestone occurring at roughly 6 week intervals exist to facilitate coarse-grained planning and staging. The milestones are:

  • Thursday, November 10 - Milestone 1 (2.0 M1) - Stable Build based on Eclipse 3.2 M3
  • Thursday, January 5 - Milestone 2 (2.0 M2) - Stable Build based on Eclipse 3.2 M4
  • Thursday, March 2 - Milestone 3 (2.0 M3) - Stable Build based on Eclipse 3.2 M5 - API complete - API freeze
  • Thursday, April 13 - Milestone 4 (2.0 M4) - Stable Build based on Eclipse 3.2 M6 - feature complete - development freeze - lock down and testing begins

The 2.0 release is targeted for late 2Q2006. All release deliverables will be available for download as soon as the release has been tested and validated in the target operating configurations listed below.

Target Operating Environments

In order to remain current, each release of an Eclipse project targets reasonably current versions of underlying operating environments and other Eclipse projects on which it depends. 

Most of Eclipse is "pure" JavaTM code and has no direct dependence on the underlying operating system. The chief dependence is on the Eclipse Platform, and on the Java 2 Platform that runs it.

The UML2 2.0 release depends on the following:

  • Java 2 Platform 1.5
  • Eclipse Platform 3.2
  • EMF 2.2

The 2.0 release of UML2 is designed to run on any configuration supporting the above components.

The Eclipse Platform runs in a variety of operating environments. Testing is focused on a handful of popular combinations of operating system and Java 2 Platform; these are our reference platforms. Eclipse undoubtedly runs fine in many operating environments beyond the reference platforms we test. However, since we do not systematically test them we cannot vouch for them. Problems encountered when running Eclipse on non-reference platform that cannot be recreated on any reference platform will be given lower priority than problems with running Eclipse on a reference platform.

See the Eclipse Project 3.2 plan for a list of reference platforms.


Eclipse is designed as the basis for internationalized products. The user interface elements provided by the various Eclipse projects, including dialogs and error messages, are externalized. The English strings for UML2 are provided as the default resource bundles. Translations are not provided with this release. However, the plug-in fragment mechanism provides the means by which translations into any number of other languages can be incorporated.

Compatibility with Previous Releases

Compatibility of Release 2.0 with 1.x

Eclipse UML2 2.0 will not be compatible with UML2 1.x.

API Contract Compatibility: UML2 2.0 will not be upwards contract-compatible with UML2 1.x as noted in the UML2 2.0 Migration Guide. Programs that use affected APIs and extension points will need to be ported to UML2 2.0 APIs. Downward contract compatibility is not supported. Compliance with UML2 2.0 APIs would not ensure compliance with UML2 1.x APIs. Refer to Evolving Java-based APIs for a discussion of the kinds of API changes that maintain contract compatibility.

Binary (plug-in) Compatibility: UML2 2.0 will not be upwards binary-compatible with UML2 1.x as noted in the UML2 2.0 Migration Guide. Downward plug-in compatibility is not supported: plug-ins compiled against UML2 2.0 will be unusable with UML2 1.x. Refer to Evolving Java-based APIs for a discussion of the kinds of API changes that maintain binary compatibility.

Source Compatibility: Source files written to use UML2 1.x APIs will not compile and run successfully against UML2 2.0 APIs. In some cases, it may be necessary to make minor changes to the source code to disambiguate things like imports or overloaded method invocations. Downward source compatibility is not supported. If source files use new APIs, they will not be usable with earlier versions.

Workspace Compatibility: Eclipse UML2 2.0 will not be upwards workspace-compatible with UML2 1.x as noted. This means that workspaces and projects created by an Eclipse with UML2 1.x installed cannot be successfully opened by an Eclipse with UML2 2.0 installed. This includes both hidden metadata, which is localized to a particular workspace, as well as metadata files found within a workspace project, which may propagate between workspaces via file copying or team repositories. User interface session state may be discarded when a workspace is upgraded. Downward workspace compatibility is not supported. Metadata files created (or overwritten) by the newer version will generally be unusable with older versions.

Non-compliant usage of API's: All non-API methods and classes, and certainly everything in a package with "internal" in its name, are considered implementation details which may vary between operating environment and are subject to change without notice. Client plug-ins that directly depend on anything other than what is specified in the API are inherently unsupportable and receive no guarantees about compatibility within a single release much less with an earlier releases. Refer to How to Use the Eclipse API for information about how to write compliant plug-ins.


The changes under consideration for the next release of Eclipse UML2 address a few major themes:

  • Built To Last - UML2 has always been a framework for delivering integrated modeling tools. With a growing base of both free and commercial offerings based on UML2, it's critical for continued success to maintain API stability and ensure that the framework scales well. This theme includes work to measure and improve the performance and scalability of UML2 resources.
  • Completeness - This theme includes consolidation activities where groundwork was laid in 1.x but needs to be completed and brought into full use.
  • Simple To Use - The UML2 framework needs to not only provide the features that advanced developers demand, but also be something that most developers find simple to use. This theme includes ease-of-use reviews of existing features, and work that helps make UML2-based products simple to use for developers with widely-varying backgrounds and skill sets.
  • Rich Client Platform - The Eclipse RCP is a Java-based application framework for the desktop. Building on the Eclipse runtime and the modular plug-in story, it is possible to build applications ranging from command line tools to feature-rich applications that take full advantage of SWT's native platform integration and the many other reusable components that the Eclipse platform provides. This theme includes work to provide UML2 support for developing and deploying RCP-based applications.
  • Broadening The Community - This theme includes work that grows deeper roots into the various domain-specific communities, spreads UML2 to additional operating environments, and builds bridges to other open source communities.
  • Release Currency - Tools projects will maintain release currency concurrent with 3.x releases. For UML2 2.0, this means currency with Eclipse 3.2 and EMF 2.2.

Each theme has a number of items; the relevant theme is identified for each committed, proposed, and deferred plan items.

The items listed reflect new features or areas where existing features will be significantly reworked. Numbers in parentheses link to bugzilla problem reports for that plan item.

The current status of each plan item is noted:

  • Committed plan item - A committed plan item is one that we have decided to address for the release.
  • Proposed plan item - A proposed plan item is one that we are considering addressing for the release. Although we are actively investigating it, we are not yet in a position to commit to it, or to say that we won't be able to address it. After due consideration, a proposal will either be committed or deferred.
  • Deferred plan item - A reasonable proposal that will not make it in to this release for some reason is marked as deferred with a brief note as to why it was deferred. Deferred plan items may resurface as committed plan items at a later point.

UML2 project

UML2 is an EMF-based implementation of the UMLTM 2.x metamodel for the Eclipse platform. Plan items reflect new features of the UML2 project, or areas where existing features will be significantly reworked ( marks completed work).

Committed Items (UML2 project)

Eclipse 3.2 / EMF 2.2 Compatibility. Maintain release currency concurrent with EMF 2.2 (and Eclipse 3.2). Make changes as required to align with EMF bug fixes. (87260) [Theme: Release Currency]

UMLTM 2.1 Conformance. Implement the revised package merge algorithm and regenerate the code using a source model based on the finalized UMLTM 2.1 Superstructure specification (compliance level L3). Update UML2 resources (libraries, metamodels, profiles), examples, and EMF generator extensions as necessary. Enhance the generator extensions (developed in UML2 1.1) to facilitate code generation for an arbitrary compliance level. (80305) [Theme: Completeness]

UML2 2.0 Migration. Provide a resource migration mechanism to migrate resources based on the UML2 1.x schema to 2.0. (105191) [Theme: Completeness]

Reduced Memory Footprint / Improved Performance. Reduce the memory footprint of UML. Improve performance of key operations such as model load, save, traversal, etc.. (85176) [Theme: Built To Last]

Supressed EMF Types. Consider suppressing EMF types in the generated code by turning on the 'Model Feature Defaults > Suppress EMF Types' generator option. (80311) [Theme: Simple To Use]

Resource Fragments. Provide support for segregation of UML2 resources into 'fragments' (e.g. *.fragment.uml2) with packages as root elements. (80312) [Theme: Simple To Use]

Derived Features. Make derived features changeable (where appropriate) and consider using EMF feature maps to implement unions, subsets, and supersets (where possible). (80313) [Theme: Simple To Use]

Improved Convenience Methods. Provide improved factory and convenience methods. For example, factory methods that accept a name as an argument (for named element creation), and retrieval methods that accept arguments indicating whether name comparisons should be case-sensitive and whether elements should be created on demand. Ensure that metadata exists for custom operations. Also provide query methods for retrieving the reverse of one-way references (depends on resolution for EMF bug 75922). (85179) [Theme: Simple To Use]

UML Ecore Importer / Exporter. Provide an exporter that takes advantage of the new exporter framework in EMF to convert Ecore models to UML (*.uml) models, in addition to an importer that converts UML models to Ecore. (122863) [Theme: Completeness]

UMLTM 2.1 Interchange. Provide support for importing/exporting resources based on the official OMG XMI representation of UMLTM 2.1. (80306) [Theme: Completeness]

RCP Support. Provide support for Rich Client Platform where applicable. (80316) [Theme: Rich Client Platform]

 Enhanced Icons. Provide meaningful icons for most, if not all, of the types in UML. (85177) [Theme: Simple To Use]

 Javadoc. Complete the generation of model documentation from the UMLTM 2.1 source model. (80315) [Theme: Simple To Use]

Proposed Items (UML2 project)

Unit Tests. Complete the implementation of generated unit tests. (80308) [Theme: Completeness]

Improved Documentation. Improve UML2 documentation by updating the FAQ, enhancing the Javadoc, and publishing new articles. (77413) [Theme: Simple To Use]

Deferred Items (UML2 project)

Validation Rules. Complete the generation and implementation of validation rules from the UMLTM 2.1 source model. (80307) [Theme: Completeness]

Tools. Engage partners and tool developers to contribute tools based on UML2, e.g. a mechanism for import/exporting resources based on Unisys XMI for UML 1.x. (80318) [Theme: Broadening The Community]

OCL Support. Provide support for constraints specified in OCL. Requires EMF support for OCL (e.g. an OCL parser/interpreter). Consider providing a convenience method on Constraint for returning the parsed representation of OCL expressions. (105199) [Theme: Completeness]