blob: 21a33c27ddc4e6ec9be3873d6aa4c4f37fee4f68 [file] [log] [blame]
<?php require_once($_SERVER['DOCUMENT_ROOT'] . "/"); require_once($_SERVER['DOCUMENT_ROOT'] . "/"); require_once($_SERVER['DOCUMENT_ROOT'] . "/"); $App = new App(); $Nav = new Nav(); $Menu = new Menu(); include($App->getProjectCommon()); # All on the same line to unclutter the user's desktop'
$pageTitle = "EMF Tiger - Component Proposal";
$pageKeywords = "emf, emft, ecore, model transformations, graph transformations";
$pageAuthor = "Christian Krause, Karsten Ehrig";
<div id="maincontent">
<div id="midcolumn">
<h1>EMF Tiger - Component Proposal</h1>
include_once($_SERVER['DOCUMENT_ROOT'] . "/projects/fragments/proposal-page-header.php");
generate_header("Eclipse Modeling Framework Tiger");
EMF Tiger is a proposed new open source project under
<a href="">Eclipse Modeling Framework Technology (EMFT)</a>
to provide a model transformation based
on structured data models and graph transformation concepts.
This component is in the Pre-Proposal Phase (as defined in the
<a href="">Eclipse Development Process</a>)
and this document is written to declare its intent and scope. This
proposal is written to solicit additional participation and input from
the Eclipse community. You are invited to comment on and/or join in the
development of the component. Please send all feedback to the
<a href=""></a>
In this document, we propose a new model transformation framework for <a href="">EMF</a>, called EMF Tiger.
<h3>Model Transformation Languages</h3>
In model driven engineering, the notion of model transformation refers
to techniques for defining and performing complex operations on structural
data models. Two different types of model transformations can be distinguished:
<li><b>Exogenous / source-target transformations:</b>
a model of a source language is translated into a model of a target language.
<li><b>Endogenous / in-place transformations:</b>
a single model is modified directly.
Endogenous transformations are often considered as a special case of
exogenous transformations where the source and the target metamodel
are identical. From another perspective, one can also regard the source,
target and an additional reference metamodel in an exogenous transformation
as a joint metamodel of an endogenous transformation.
Both viewpoints are valid. To that end, the purpose of a model
transformation often determines its type, e.g. language translations
are usually exogenous while refactorings or reconfigurations are endogenous.
There are different ways of defining and executing model transformations
and it is important to note that there is in fact a difference between
the two types of transformations.
Just as with programming languges, there are also different kinds of model
transformation languages which usually support both types of transformations
but in fact are more suited for only one of them. One can basically
distinguish between declarative (using pattern matching), procedural
(using control-flow structures) and hybrid languages which combine
both approaches.
Similar to ordinary programming languages (or e.g. compilers),
verification of correctness and termination of model transformations
is a crucial and at the same time non-trivial task.
<h3>EMF Tiger</h3>
EMF Tiger is a tool environment for EMF model transformation.
Transformations are defined and executed
directly on EMF models, ensuring type safety and efficiency.
Model transformation can be executed either using
generated code or in an interpreter mode.
The rule-based transformation language of EMF Tiger is inspired by graph
transformation concepts and
combines both declarative and procedural concepts.
In particular, transformation rules are declarative in the sense
that a structural pattern is used to define the precondition of
a rule. Procedural concepts, i.e., control-flow strutures such as
layers and loops can be used to apply a set of transformation rules
in a controlled manner.
Since most EMF transformations performed by
EMF Tiger can be formalized by the theory of algebraic graph
transformation (see e.g. <a href="">[BET08]</a>
(<a href="">PDF</a>)),
these model transformations can be verified.
In currently ongoing research,
we investigate how existing techniques for
termination and confluence (correctness)
checks can be adapted to EMF transformations.
As future work, we also plan to incorporate model checking
techniques for a detailed analysis of model transformations.
The EMF Tiger tool environment currently consists of the following constituents:
<li>a transformation model</li>
<li>a transformation engine (interpreter approach)</li>
<li>a code generator that produces self-contained transformation code in Java (based on EMF-generated code)</li>
<li>a tree-based editor for transformations rules (generated with EMF)</li>
<li>a graphical editor for transformations rules</li>
<li>export utilities for third-party graph transformation tools (for analysis)</li>
The frontend is currently under reconstruction. We plan a set of
GMF-generated editors for instance models and transformation rules.
Furthermore, a visual debugger for model transformations is planned.
Our long-term goal is to make EMF Tiger a comprehensive tool environment for
endogenous in-place EMF model transformations. It shall comprise
convenient user-friendly editors for complete model transformation
systems, including already existing EMF model editors, a visual
debugger, code generator facilities, as well as validation and
verification tools for EMF model transformation.
<h3>Language Concepts</h3>
EMF Tiger is a rule-based transformation language with both,
declarative (pattern matching) and procedural aspects (control-flow structures).
A transformation rule consists of two model instances (a set of objects with
references between them): a left-hand side (LHS) and a right-hand side (RHS).
The LHS defines the pattern to be matched (precondition) and the RHS the
in-place modification (postcondition) of the matched model instances.
Optional negative application conditions (NACs) can be defined for restricting
the rule application further.
Rules can be executed nondeterministally (from a pool) or using
control-flow structures (e.g. layers and loops). Transformations can further
include calculations on attributes. The calculations are defined as an
expression on the attributes that may also involve (primitive-valued) variables.
The transformation language is defined through a metamodel. Currently,
there exists a tree-based editor generated using EMF, and a graphical
editor shown in the screenshot below.
<p><img src="proposal_files/editorSC.png"></p>
This front-end consists of a (read-only) viewer for the domain models and
a three-pane editor for defining rules.
In this example a model for a simple refactoring for a statechart
variant is shown. This particular rule moves a state (3:State) out of a
composite state (2:State) up into its parent (1:State).
This is possible, if all adjacent transitions already belong to the
surrounding state. This condition is checked by two similar NACs, one
of which is shown together with the rule.
EMF Tiger supports code generation from transformation specifications
as well as an interpreted runtime mode.
<h3>Comparison with other Model Transformation Languages</h3>
<p>The most important model transformation approaches for EMF are:</p>
<li> <a href="">ATL (ATLAS Transformation Language)</a> </li>
<li> <a href="">Procedural QVT (Operational)</a> </li>
<li> <a href="">Declarative QVT (Core and Relational)</a> </li>
<li> <a href="">Xpand and Xtend (openArchitectureWare)</a> </li>
<li> <a href="">Epsilon</a> </li>
Comparing the EMF Tiger transformation language to these languages, the first obvious commonality is
the rule-based definition of transformations and the use of declarative and procedural concepts.
At second glance, the approach of EMF Tiger for defining and executing both source-target and
in-place transformations is quite different
to the other languages.
Particularly in-place transformations are not very well supported by
the existing languages. For instance, ATL is defined as a language that
<i>'provides ways to produce a set of target models from a set of source models'</i>.
Although it is basically possible to define in-place transformations in ATL,
this way is not that natural because in-place transformations have to be
regarded as exogenous transformations where the source and the target
metamodels are the same.
This has major consequences on the execution of in-place transformations, i.e.,
instead of performing the transformations directly on a given a model (as it is
natural for e.g. refactorings or reconfigurations),
large parts of the source model have to be copied in ATL.
Especially for large models and small changes this is highly
inefficient. It is similar with QVT, since in-place transformations are also defined as
a special type of source-target transformations.
EMF Tiger supports both in-place and source-target transformation.
In-place transformations in particular can be very elegantly described
and executed efficiently, since the transformations are applied directly
to an existing instance model.
In contrast to in-place transformations, source-to-target translations require
an additional reference model that keeps track of newly created elements. Note
that the transformation engine itself is oblivious to the type of transformation
performed, i.e., internally source-target and in-place transformations are
treated in the same way.
Another key difference of EMF Tiger is its formalization by
graph transformation theory (see <a href="">[EEPT06]</a>
or this <a href="">tutorial</a>),
which enables formal analysis of transformations. Moreover, EMF Tiger
supports the visual development of transformations through its
native graphical notation.
<h2>Relationship to other Eclipse Projects</h2>
Apart from the core EMF tools, EMF Tiger uses
<a href="">JET</a> for code generation and
<a href="">GEF</a> for the graphical editor.
We currently adapt the graphical editor to use the
<a href="">GMF</a> notation view model
and runtime. As a longterm goal, we are planning to partially generate
the editor using GMF's code generator.
As a first case study we are working on a number of refactoring
rules for EMF itself (defined on its metamodel) and UML-2.
<li>Ed Merks (<a href="">Macro Modeling</a>, Canada)</li>
<li>Bernd Kolb (<a href="">SAP</a>, Germany)</li>
<h3>Initial Committers</h3>
The initial committers for this project are:
<li> Christian Krause (<a href="">CWI Amsterdam</a>), proposed project lead</li>
<li> Enrico Biermann (<a href="">Technische Universität Berlin</a>), committer</li>
<li> Stefan Jurack (<a href="">Philipps-Universität Marburg</a>), committer</li>
<h3>Code Contributions</h3>
The <a href="">EMF Tiger Developer Group</a>
at the TU-Berlin will provide an initial code contribution including the code
generator and the graphical user interface.
<h3>Interested Parties</h3>
<p>The following parties have expressed their interest in EMF Tiger:</p>
<li><a href="">ATX Technologies (Carlos Matos)</a> </li>
<li><a href="">Eclipse GMF</a> </li>
<li><a href="">HiPeS (Jim van Dam)</a> </li>
<li><a href="">IBM Zurich Research Laboratory (Jochen Küster)</a> </li>
<li><a href="">Siemens Corporate Technology (Nikolaus Regnat)</a> </li>
<h3>Developer Community</h3>
The team of initial committers will explore statements of interest from
additional developers experienced with EMF model transformations or
willing to gain such experience.
<h3>User Community</h3>
It is expected that the user community for this
component will consist of two kinds of users.
On the one hand, there will be researchers and developers who design EMF transformations
and on the other, there will be developers who integrate the generated EMF model
transformation code in their own applications.
<h2>Tentative Plan</h2>
The first community technical preview release is
scheduled for Winter 2009 and the first release is targeted for Summer 2010.
<h2>Further Information</h2>
Further information can be found on the
<a href="">EMF Tiger Website</a>
at the TU-Berlin.
$html = ob_get_contents();
# Generate the web page
$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);