The Umple Model-Oriented Programming project is a proposed open source project under the Modeling Container 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 Eclipse Proposals Forum.

Background

In our research at the University of Ottawa, we made several observations:

As a result we set out to construct Umple. The initial ideas were conceptualized in the mid 2000's. The first version of Umple was created in the Masters thesis of Dusan Brestovansky in 2007. Since then Umple has been developed as part of several PhD and Masters theses. A list of publications describing Umple can be found at http://publications.umple.org

Scope

The Umple project encompasses a model compiler and related technology. The components of Umple are listed below. These are tagged as follows according to maturity: [M0] Widely deployed in industry, robust and stable (none so far in Umple); [M1] Deployed to key users and can be used for industrial development (thoroughly tested; stable); [M2] well developed, but in need of further development, quality assurance and/or stability improvement; [MD] Under development; [MF] Future plans; [MM] Was developed but has not ben maintained, so needs bringing up to date. Combinations of numbers and letters mean that there are parts that are mature, and parts that are under development, future plans, etc.

  1. The textual programming-language-like syntax called Umple, covering

    1. UML constructs including associations [M1], attributes [M1], state machines [M1], active objects and components components [MD], consraints [MD], concurrency [M2F], etc.
    2. Real-time profiles such as Marte and AutoSar [MF]
    3. Builtin patterns such as singleton [M1], and immutable [M1], as well as an ability to define other patterns [MF].
    4. Separation of concerns in the context of Umple including mixins [M1], aspect-oriented code injections [M1F], and variability modeling constructs [M2F]
    5. A tracing sublanguage (MOTL) allowing injection of tracepoints into modeling constructs [M2F]
  2. Technology for embedding programming languages such as Java [M1], PhP [M2], Ruby [M2], C++ [M2], and Alf [MF] into Umple, and vice-versa.

  3. A grammar DSL optimized for processing Umple and the embedding of languages, but also capable of being used in other contexts [M1]

  4. A subsystem for analysing the syntactic and semantic validity of models in Umple [M1F]

  5. Generation and transformation capabilities related to Umple:

    1. A generic code-generation architecture designed to work with Umple, but also capable of working with other modeling front-ends [M1]
    2. Specific code generators for various languages including Java [M1], PhP [M2], Ruby [M2], C++ [M1D], covering all the syntactic elements described above
    3. Generators for creating UML and other diagrams from Umple [M1F]
    4. Generators for exporting Umple to formats such as other UML representations (XMI [M2F], Yuml [M2], etc.), SDL [MD] and SQL [M2]
    5. Generators for metrics and other data about Umple systems [MD]
    6. Generators for formal languages [MF]
    7. Generators for automatic testing of Umple-generated code [MD]
  6. Capabilities for importing into Umple various formats such as XMI, and for connecting Umple to other tools for import, export, diagram generation, etc. [MF]

  7. An Eclipse plugin supporting all of the above.

  8. An XText-based Eclipse plugin to give Umple improved syntax-directed editing, and a tool to convert the Umple grammar to XText.

  9. A website (UmpleOnline) for editing Umple and UML diagrams interchangeably and generating code and other artifacts

  10. Metadata for the Umple user manual, and a tool to generate the user manual from this metadata<./p>

  11. Tools to generate self-documenting elements of the Umple compiler and other systems written in Umple.

  12. A User-Interface generation tool (UIGU) to generate usable default websites from any given Umple model for rapid prototyping.

  13. A tool to facilitate transformation of code to Umple models+code (umplification).

  14. An extensive suite of testcases to test the syntax, Umple metamodel, and generated code.

  15. Example systems and models (partial systems) written in Umple to serve as additional tests as well as for demonstration of Umple capabilities..

  16. Libraries of reusable modeling components written in Umple.

  17. Plugins to various external editors to provide those editors with an Umple profile for such capabilities as syntax-directed editing, generating of Umple from their tools, etc.

Description

Umple, In short, is a compiler, written in itself that adds modeling abstractions to languages such as Java, PhP and C++ (targeting gcc and Microsoft visual studio). Its core tools are a standalone command-line compiler, an Eclipse plugin and a website for educational and demonstration use. To a programmer, Umple appears as a programming language with advanced features (state machines, associations, concurrency constructs, patterns) that are specified directly in the code, harmoniously with the other code. To a modeller, Umple appears as a textual way to write UML and embed Java, PhP and/or C++ directly in the model. See http://try.umple.org for the demonstration website http://code.umple.org for the current open source site http://manual.umple.org for the full-featured generated user manual http://dl.umple.org for various ways to download Umple and http://metamodel.umple.org for the generated UML class diagram of the system with hot links to documentation and live code. In Umple, we have followed a rigorous but agile development process. Some features of that process include: - Test driven development: We have several thousand test cases, and we have zero tolerance for test failure in a commit or patch. New contributions must include executable tests that demonstrate the correct functioning of the feature. - Self-reflexive system: Umple is written in itself. The Umple compiler therefore is a very large test case. - Continuous integration: Every commit triggers a build (a committer is responsible for fixing the build if he doesn't follow proper process, resulting in a broken build). On every build the system is first built with the most recent version of the compiler, then rebuild with the version just built. Following every successful build, a new 'bleeding edge' version of the compiler is publicly available. UmpleOnline always uses this version. The research that has developed Umple has come through several grants. Sponsors of those grants have been IBM (from the very beginning), Ericsson, General Motors, Malina and the Governments of Canada (NSERC) and Ontario (ORF). Funding for the next three years is secure.

Why Eclipse?

Umple needs the visibility and IP policies that an organization like Eclipse can provide, in order to help foster industrial uptake. Since Umple has been developed in Eclipse, and has an Eclipse plugin as one of its main artifacts, the Eclipse foundation seems the right home. Also according to XXXX Eclipse is one of the most open of open-source initiatives. Umple has always prided itself in being extremely open, and we want this to continue. The main benefits Umple would bring to Eclipse would be: - A flexible tool to allow integration of textual model constructs right into code in one or more languages. The textual form allows models and code to be seen as a unified artifact, facilitating version control, product-line development, bug tracking, etc. But the model can still be edited graphically. - A new sophisticated code generation capability that we believe might be the best availale in open source. Two PhD theses have gone into our state machine generation and UML association generation. We handle infinte nesting and concurrency levels, plus referential integrity and many other issues. - The only modeling tool written in itself, demonstrating the power of model-driven development and helping assure quality. - A flexible architecture that allows interaction with many tools both inside and outside the Eclipse ecosystem (e.g. we can plug in code generators, diagram generators, export generators, fairly easily and can extend the language easily)

Initial Contribution

Umple has been an open source project under Google Code since 2011. It is licensed under the MIT license. Copyright is jointly held by the contributors, who, by virtue of agreeing to release their contributions under the MIT license have allowed their work to be freely used.

Legal Issues

There should be no important legal issues that we are aware of. The project is under the MIT license. We have no objection to converting to the Eclipse Public License going forward. The project does have dependencies on some other Eclipse projects (e.g. Jet). The website also uses CodeMirror and JQuery which are licensed under the MIT license. There is the issue of the generated code. When code is emitted it no license is injected, Our concept is that the original model can have whatever license users want, and the generated code would have the same license. There is also the issue of the example Umple code and models. In order to foster uptake of Umple, we would like to allow people to freely copy and paste from these examples. The MIT license seems ideal for that;

Committers

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

Committer 1, Affiliation
Committer 1 is a committer on the *** project where he has made significant contributions over many years. S/he will be contribute to the *** functionality in this new project.
Committer 2, Affiliation
Committer 2 has provided significant contributions to the existing code base. S/he will contribute to the *** functionality in this new project.

We welcome additional committers and contributions.

Mentors

The following Architecture Council members will mentor this project:

Interested Parties

The following individuals, organisations, companies and projects have expressed interest in this project:

Project Scheduling

We would like to convert to Eclipse in mid-summer 2013 (July).

This is a mature project with users and ongoing rapid development. There are also gradate students working on Umple as part of their thesis. We want to avoid disrupting their work.

As a result, during the proposal and initial Eclipse incubation pase, we will route all commits to Coogle Code and also to Eclipse until the Eclipse-based environment is stable. At this point the plan would be to number the first non-incubation release as 2.0.

Other mirrors would then become downstream to the Eclipse version.

Changes to this Document

Date Change
DD-Month-YYYY Document created