OMG Specification and Eclipse Project Overview

Ed Willink, Project Lead, Eclipse Modeling Project

The complementary roles of OMG and Eclipse will be reviewed. Then the most important OMG specifications and Eclipse modeling projects will be summarized, highlighting the way in which distinct specifications fit together and how particular projects relate to those specifications.

This talk will describe the background, status and intial products of the currently ongoing effort to simplify the specification of UML. Now, everyone realizes that UML 2 is a large and complicated language, so it is not surprising that the specification for the language is also large and complicated. However, the current UML 2 specification often seems gratuitously hard to comprehend, even for experts: It is divided into two volumes (Infrastructure and Superstructure), which together define five compliance levels whose definition relies extensively on the otherwise rarely used package merge construct. And, to be honest, despite years of issue revision work, the specification is still riddled with obscure writing and outright inconsistencies. With UML 2.5, this will all change. UML 2.5 will still be essentially the same language as UML 2.4.1, but the specification for it is being rewritten from top to bottom: There will be no separate infrastructure. There will be no compliance levels. There will be no use of package merge. Instead, the UML abstract syntax, semantics and notation will be described as clearly and consistently as possible in authored text, with supporting metamodel documentation generated directly from the model itself. This will still not be a document to hand to a beginner to learn UML -- but at least it will be a specification that experts and implementors can comfortably use as a definitive basis for the tutorials and tools on which the rest of the UML community depends!

With renewed interest in keeping its implementation up to date with changes made by the OMG, the Eclipse UML2 project has recently received some much needed attention such that it can once again support construction of state of the art UML-based tooling at Eclipse (and beyond). Join us for an overview of what's new in UML2 for the upcoming Juno release of Eclipse, including compliance with UML 2.4(.1), source code hosted in git, and a brand new Buckminster build running on Hudson. Time permitting, we'll also take a look at UML2's updated support for model interchange based on the latest MOF and XMI specifications.

The abstract syntax of a graphical modeling language is typically defined with a metamodel while its concrete syntax (diagram) is informally defined with text and figures. Recently, the Object Management Group (OMG) released a specification, called Diagram Definition (DD), to formally define both the interchange syntax and the graphical syntax of diagrams. In this work, we validate DD by using it to define a subset of the UML class diagram. Specifically, we define the interchange syntax with a MOF-based metamodel and the graphical syntax with a QVT mapping to a graphics metamodel. We then run an experiment where we interchange and render an example diagram using Eclipse-based tooling. We highlight various design decisions and discuss challenges of using DD in practice. We find that DD is a sound approach for formally defining diagrams that is expected to facilitate the interchange and the consistent rendering of diagrams between tools.

Papyrus (UML2, SysML, MARTE)

Remi Schneckenburger- Commissariat a l Energie Atomique-CEA

Since its first version available on the Eclipse foundation servers two years ago, Papyrus modeler has evolved much. It now provides editors for most of the UML diagrams, and plan to implements this year the last missing ones. It also provides a full compliant SysML profile implementation, on which 3 SysML-based diagrams editors are built : Block Definition diagram, Internal Block Diagram and Requirement Diagram. Finally, it provides a reference implementation of the MARTE profile in the Eclipse platform.

GMF Tooling 3.0

Michael Golubev- Team Head Thinktank Prague, Montages

Michael Guttman- CEO, The Voyant Group, LLC

Philipp Kutter- CEO, Montages

- The way the project is sponsored and organized since 2011
- How the MDA Architecture of GMF Tooling works (PIM, PSM)
- The new features of GMF for 2012:
- PIM to PSM transformation with QVTO
- Configuration with OCL
- "Diaglets" as new reuse components for visual editors
- Targeting of different runtime plaforms (GMF Runtime and Grafiti Runtime)
- The planned topics for 2013:
- Tighter collaboration with other OMG implementations (OCL, QVTO)
- A small visual DSL to create visual editors in minutes

Currently, our relations to BPMN 2.0 OMG specification are:
- We can import/export BPMN2.0.
- We are respecting the visual notation in our GMF diagram.
- Awarded "Best Modeling Application" by Eclipse Community Awards 2011

The Business Process Modeling Notation is the global standard for process modeling, and brings business and IT together. BPMN2 is a new version of this specification, which ensures the interoperability of designed models and graphic presentations.

Our new version of BPMN design tool has been created with W4, specialist in process automation. It relies on the BPMN2 meta-model and provides a world-wide first native visual design capability in Open Source. In this talk, we walk through all capabilities of this new design tool in live demo. It will list some important weaknesses of the current modeling edition tools for business users, and our solutions implemented in BPMNComposer (http://www.bpmncomposer.org/).

The agenda is:
- Design Goals
- Demo
- Main Features
-Roadmap

XOCL
Philipp Kutter- CEO, Montages

Michael Guttman- CEO, The Voyant Group, LLC

Said Tabet- Senior Consultant, Montages

A talk on XOCL: a set of EAnnotation with OCL to make ECore models executable
- The current status of XOCL, short demo
- The three kinds of annotations: derivations, constraints, and update
- The design rational behind XOCL, especially the way how updates are specified

OCL has traditionally been an interpreted language limiting the run-time performance of OCL-based modeling tools. In this talk we describe recent innovations that address OCL useability performance.

- The Eclipse OCL editors exploit Xtext to enable OCL to be edited and checked directly within Ecore models.
- The Eclipse OCL code generator totally eliminates the need for any OCL parsing at run-time. Direct Java code is generated when a model is genmodelled. This may easily yield thousand-fold improvements for the first execution of a simple query.
- The associated Eclipse OCL run-time exploits a polymorphic library and the dispatch tables provided by the code generator to totally eliminate interpretation overheads. This may yield between 5 and 50-fold improvements in execution speed.
- Formal query languages support analysis and consequently allow optimization of queries for re-evaluation. This may improve speed by many orders of magnitude for large models enabling model-defined execution to far outperform manual Java code.

We will conclude by showing how the code generator innovations lay the foundations for a transformation virtual machine that may support QVT and other languages.

High performance queries and their novel applications

István Ráth- Research Associate, BME

High-performance model queries are still a major challenge for the industry standard Eclipse Modeling Framework (EMF), they are intensively used in various model validation, model transformation or code generation scenarios. Existing EMF-based query technologies (like Eclipse OCL, EMF Model Query 1-2, or native Java programs) can have significant scalability issues for complex queries of models over 50-100000 model elements. Moreover, it is often tedious and time consuming to efficiently implement EMF-based queries manually on a case-by-case basis.

Recent initiatives, such as the EMF-IncQuery framework (http://viatra.inf.mit.bme.hu/incquery) have proposed innovative algorithms to mitigate this issue. EMF-IncQuery uses a graph query language, and provides incremental query evaluation by caching the results of the model queries and incrementally maintaining the cache when the underlying EMF model changes. Furthermore, the EMF-IncQuery framework can be easily integrated into existing EMF-based applications in a non-intrusive way.

In the first part of the talk, we overview the results of a thorough benchmark comparison
intended to aid software engineers in picking the best tool for a given purpose. The measurements involve several versions of Eclipse OCL, manually optimized Java code, dedicated academic query and well-formedness checking tools and EMF-IncQuery and highlight the most important practical considerations of queries in model-driven tool design.

In the second part of the talk, we briefly overview novel and innovative uses of high performance queries such design-space exploration, whereby traditional modeling is augmented with AI techniques to aid the (semi-automatic) optimization of model-based software designs.

State of the art on the QVT Model to Model Transformation specification and project.

We will start with a short introduction of the Acceleo project, its language based on MOFM2T and its core principles. Then we will realize a code generator while presenting the tooling embedded in Acceleo. Here we will start with a working prototype and, following the prototype-based approach, we will use the code of the prototype to configure a generator.

We will then evolve our generator and consider another approach for editing our templates in which we will write code directly in the output language inside of our templates and we will see how Acceleo helps us during the maintenance of our generators with the support of the target language directly in the editor.

We will consider a final stage in the life of our generator during which we will use, maintain and override parts of the behavior of an existing generator assited by the traceability information computed by Acceleo.

With the growing use of DSL in industry, DSL design and implementation goes far beyond an activity for a few experts only and becomes a challenging task for thousands of software engineers. DSL implementation indeed requires the engineers to care for various concerns, from abstract syntax, static semantics, behavioral semantics, to extra-functional issues such as runtime performance.

In order to provide a convenient level of abstraction and expressiveness, the design of a DSL often need the combined use of several meta-languages (meta DSL) such as the one provided by OMG or Eclipse (MOF, Ecore, OCL, QVT, Action Language for Foundational UML, ...)

As an executable meta language, Kermeta language and its workbench can be used for various software engineering purposes: code-generation, model-based testing, model transformation, model simulation, etc. However, this presentation will focus on some of the features of Kermeta in order to show how we use them to seamlessly combine meta DLSs when building tools. The usage and combination of those meta-languages with kermeta is simple and intuitive enough to deserve the term mashup.

The approach emphasis on the following practical requirements:
- Each DSL implementation concern can uses of an appropriate language specific meta-language ; for example: one meta-language for the abstract syntax (aligned to EMOF); one for the static semantics (aligned to OCL) and one for the behavioral semantics (Kermeta Language)
- The combination of these concerns is achieved using an efficient compilation scheme;
-Must smoothly integrates with the existing legacy components of the EMF ecosystem.

Semantic Information Modeling for Federation (SIMF) - Standard in Progress

Cory Casanave- CEO/ President, Model Driven Solutions

This presentation will discuss the OMG "SIMF" RFP, the standards process and progress thus far. The SIMF RFP asks for submissions for a standard that addresses the federation of information across different representations, levels of abstraction, communities, organizations, viewpoints, and authorities. Federation, in this context, means using independently conceived information sets together for purposes beyond those for which the individual information sets were originally defined.

The information federation and sharing problems are well known and recognized by every major organization, costing trillions of dollars annually - yet sufficient standards tailored to this problem do not yet exist. While experts in existing modeling and semantic languages can achieve semantic federation, the mainstream standards and tools required to do so are not yet available. SIMF will build on and extend current capabilities to create a semantic information modeling standard to enable mainstream adoption. It is our position that OWL or UML are not designed for this purpose and something else is needed.

SIMF builds on the well accepted ideas of "conceptual modeling" and "logical modeling" as a foundation for information federation using "model bridging relations". The semantic framework is then presented in both graphical and textual notations using OMG standards. More details can be found here: http://tinyurl.com/SIMFrfp.