Publications
2017 2016  2015  2014  2013  2012  2011  2010  2009  2008  2007  2006  2005  2004  2003  2002 and before Kristopher Born,
Leen Lambers, Daniel Strüber,
Gabriele
Taentzer:
Granularity of
Conflicts and Dependencies in Graph Transformation Systems.
(Extended Version:
Technical Report)
Awarded with the EATCS Best Paper Award
International
Conference on Graph Transformation (ICGT) 2017
Abstract.
 Nebras Nassar,
Hendrik Radke, Thorsten
Arendt:
Rulebased Repair of
EMF Models: An Automated Interactive Approach.
International Conference on
Model Transformation (ICMT) 2017
Abstract.
 Nebras Nassar,
Jens Kosiol,
Hendrik Radke:
Rulebased Repair of
EMF Models: Formalization and Correctness Proof.
Eighth
International Workshop on Graph Computation Models (GCM) 2017
Abstract.
 Dennis Priefer,
Peter Kneisel, Daniel
Strüber:
Iterative
ModelDriven Development of Software Extensions for Web Content
Management Systems.
European Conference
on Modelling Foundations and Applications (ECMFA) 2017
Abstract.
 Daniel Strüber,
Kristopher Born,
Kanwal Daud Gill, Raffaela Groner, Timo Kehrer, Manuel Ohrndorf,
Matthias Tichy:
Henshin: A
UsabilityFocused Framework for EMF Model Transformation
Development
International
Conference on Graph Transformation (ICGT) 2017
Abstract.
 Gabriele
Taentzer, Manuel Ohrndorf, Yngve Lamo, Adrian Rutle:
ChangePreserving Model Repair: Extended Version.
Short version accepted for Int. Conference on Fundamental Approaches to Software Engineering 2017
Abstract.
During modeling activities, inconsistencies can easily occur due to misunderstandings, lack of information or simply mistakes. In this paper, we focus on model inconsistencies that occur due to model editing and cause violation of the metamodel conformance. Although temporarily accepting inconsistencies helps to keep progress, inconsistencies have to be resolved finally. One form of resolution is model repair. Assuming that model changes are statebased, (potentially) performed edit operations can be automatically identified from state differences and further analyzed. As a result, inconsistent changes may be identified causing a need to repair the model. There may exist an overwhelming number of possible repair actions that restore consistency. The edit history may help to identify the relevant repairs. Model inconsistencies are repaired by computing and applying complement edit operations that are needed to reestablish the overall model consistency. In this paper, we clarify under which conditions this kind of model repair can be applied. The soundness of this approach is shown by formalizing it based on the theory of graph transformation. A prototype tool based on the Eclipse Modeling Framework and Henshin is used to conduct an initial evaluation.
 Daniel Strüber,
Felix Rieger, Gabriele
Taentzer:
A textbased visual
notation for the unit testing of modeldriven tools.
Computer Languages, Systems and Structures
Abstract.
 Kristopher Born,
Stefan Schulz, Daniel Strüber,
Stefan
John:
Solving the
Class Responsibility Assignment Case with Henshin and a Genetic
Algorithm. Awarded with the Best Quality Solution
Award
9th
Transformation Tool Contest (TTC) 2016
Abstract.
 Daniel Strüber,
Stefan Schulz:
A Tool Environment
for Managing Families of Model Transformation Rules. Awarded with
the Best Software Science Paper Award
International Conference
on Graph Transformation (ICGT) 2016
Abstract.
 Daniel Strüber,
Jennifer Plöger, Vlad Acretoaie:
Clone Detection for
GraphBased Model Transformation Languages.
Awarded with the Best Paper Award
International Conference
on Model Transformation (ICMT) 2016
Abstract.
 Timo Kehrer, Gabriele
Taentzer, Michaela Rindt, Udo Kelter:
Automatically
Deriving the Specification of Model Editing Operations from
MetaModels.
International Conference
on Model Transformation (ICMT) 2016
Abstract.
 Marsha Chechik, Michalis Famelis, Rick Salay, Daniel
Strüber:
Perspectives of
Model Transformation Reuse.
International Conference on
Integrated Formal Methods (iFM) 2016
Abstract.
An Algorithm for the
Critical Pair Analysis of Amalgamated Graph
Transformations.
International Conference
on Graph Transformation (ICGT) 2016
Abstract.
ModelDriven
Development of Mobile Applications: Towards ContextAware Apps of High
Quality.
International
Workshop on Petri Nets and Software Engineering (PNSE) 2016:
1729
Abstract.
 Dennis Priefer,
Peter Kneisel, Gabriele
Taentzer:
ModelDriven Process
to Migrate Web Content Management System Extensions.
International
Conference on Web Engineering (ICWE) 2016, Posters
Abstract.
 Dennis Priefer,
Peter Kneisel, Gabriele
Taentzer:
JooMDD: A
ModelDriven Development Environment for Web Content Management System
Extensions.
International
Conference on Software Engineeing (ICSE) 2016, Demonstrations
Abstract.
 Steffen Vaupel,
Damian Wlochowitz, Gabriele
Taentzer:
A Generic
Architecture Supporting ContextAware Data and Transaction Management
for Mobile Applications.
3rd
IEEE/ACM International Conference on Mobile Software Engineering and
Systems
Abstract.
In order to support higher mobility  in the sense that operations may execute across the boundaries of changing network states  we discuss the problem and requirements for contextaware architectures of mobile applications. We present a generic architecture supporting users to effectively use applications online as well as offline. This approach enables the concurrent execution of offline transactions as well as their durability after synchronization. Starting from example applications, we analyze the design of existing contextaware architectures and corresponding mobile transaction models and present our approach to a generic architecture. Furthermore, we frame various conditions for advantageously using mobile transaction models.
Deriving
Model Metrics from Meta Models.
"Modellierung"
2016
Abstract.
 Daniel Strüber,
Julia Rubin, Thorsten Arendt,
Marsha Chechik, Gabriele
Taentzer, Jennifer Plöger:
RuleMerger:
Automatic Construction of VariabilityBased Model Transformation
Rules.
Fundamental Approaches to Software Engineering (FASE) 2016
Abstract.
Unifying similar model transformation rules into variabilitybased ones can improve both the maintainability and the performance of a model transformation system. Yet, manual identification and unification of such similar rules is a tedious and errorprone task. In this paper, we propose a novel mergerefactoring approach for automating this task. The approach employs clone detection for identifying overlapping rule portions and clustering for selecting groups of rules to be unified. Our instantiation of the approach harnesses stateoftheart clone detection and clustering techniques and includes a specialized merge construction algorithm. We formally prove correctness of the approach and demonstrate its ability to produce highquality outcomes in two reallife casestudies.
 Steffen Vaupel,
Gabriele
Taentzer, René Gerlach, Michael Guckert:
ModelDriven
Development of PlatformIndependent MobileApplications Supporting
Rolebased App Variability.
Software Engineering 2016
Abstract.
ModelDriven
Engineering in the Large: Refactoring Techniques for Models and Model
Transformation Systems.
Dissertation, PhilippsUniversität Marburg, 2016
Abstract.
ModelDriven Engineering (MDE) is a software engineering paradigm
that aims to increase the productivity of developers by raising the
abstraction level of software development. It envisions the use of
models as key artifacts during design, implementation and deployment.
From the recent arrival of MDE in largescale industrial software
development – a trend we refer to as MDE in the large –, a set of
challenges emerges: First, models are now developed at distributed
locations, by teams of teams. In such highly collaborative settings,
the presence of large monolithic models gives rise to certain issues,
such as their proneness to editing conflicts. Second, in largescale
system development, models are created using various domainspecific
modeling languages. Combining these models in a disciplined manner
calls for adequate modularization mechanisms. Third, the development of
models is handled systematically by expressing the involved operations
using model transformation rules. Such rules are often created by
cloning, a practice related to performance and maintainability
issues.
In this thesis, we contribute three refactoring techniques, each aiming
to tackle one of these challenges. First, we propose a technique to
split a large monolithic model into a set of submodels. The aim of
this technique is to enable a separation of concerns within models,
promoting a concernbased collaboration style: Collaborators operate on
the submodels relevant for their task at hand. Second, we suggest a
technique to encapsulate model components by introducing modular
interfaces in a set of related models. The goal of this technique is to
establish modularity in these models. Third, we introduce a refactoring
to merge a set of model transformation rules exhibiting a high degree
of similarity. The aim of this technique is to improve maintainability
and performance by eliminating the drawbacks associated with cloning.
The refactoring creates variabilitybased rules, a novel type of rule
allowing to capture variability by using annotations.
The refactoring techniques contributed in this work help to reduce the
manual effort during the refactoring of models and transformation rules
to a large extent. As indicated in a series of realistic case studies,
the output produced by the techniques is comparable or, in the case of
transformation rules, partly even preferable to the result of manual
refactoring, yielding a promising outlook on the applicability in
realworld settings.
 Daniel Strüber,
Felix Rieger, Gabriele
Taentzer:
MUTANT: ModelDriven
Unit Testing using ASCIIart as Notational Text.
FlexMDE
Workshop: 211
Abstract.
There are two established strategies to create test models: Textual notations require developers to mentally reconstruct the involved graph structures ad hoc; maintenance effort and time are increased. Existing visual notations compel developers to switch frequently between different editors; keeping the resulting test artifacts synchronized is complicated by insufficient tool support. In this paper, we propose to specify test models using ASCIIart  a textbased visual notation used by developers in their everyday practices. To outline our vision, we employ a motivating example and discuss challenges such as editing, collaboration, and scalability. The discussion sheds a promising light on the new idea, notably for its usefulness in collaborative and reuseintensive settings.
 Steffen Vaupel,
Daniel Strüber,
Felix Rieger, Gabriele
Taentzer:
Agile
bottomup development of domainspecific IDEs for modeldriven
development.
FlexMDE
Workshop: 1221
Abstract.
Diminishing timetomarket and rapidly evolving technology stacks stretch traditional software development methods to their limits. In this paper, we propose a novel process for bottomup development of domainspecific IDEs based on agile principles. It aims to enable a finegrained coevolution of domainspecific modeling languages (DSMLs) and their model editors and code generators. We illustrate our approach by iteratively developing an IDE for modeldriven development of mobile applications. As a key success factor for continuous DSML development, we determine the automated deduction of migration scripts for all dependent artifacts of a DSML evolution step.
 Timo Kehrer, Christopher Pietsch, Udo Kelter, Daniel Strüber,
Steffen
Vaupel:
An Adaptable Tool
Environment for Highlevel Differencing of Textual
Models.
OCL and Textual
Modeling Workshop
Abstract.
The use of textual domainspecific modeling languages is an important trend in modeldriven software engineering. Just like any other primary development artifact, textual models are subject to continuous change and evolve heavily over time. Consequently, MDE tool chain developers and integrators are faced with the task to select and provide appropriate tools supporting the versioning of textual models. In this paper, we present an adaptable tool environment for highlevel di erencing of textual models which builds on our previous work on structural model versioning. The approach has been implemented within the SiLift framework and is fully integrated with the Xtext language development framework. We illustrate the adaptability and practicability of the tool environment using a case study which is based on a textual modeling language for simple web applications.
 Gabriele
Taentzer, Ulrike Golas:
Towards Local
Confluence Analysis for Amalgamated Graph
Transformation.
International
Conference on Graph Transformation
Abstract.
Amalgamated graph transformation allows to define schemes of rules coinciding in common core activities and differing over additional parallel independent activities. Consequently, a rule scheme is specified by a kernel rule and a set of extending multirules forming an interaction scheme. Amalgamated transformations have been increasingly used in various modeling contexts. Critical Pair Analysis (CPA) can be used to show local confluence of graph transformation systems. It is an open challenge to lift the CPA to amalgamated graph transformation systems, especially since infinite many pairs of amalgamated rules occur in general. As a first step towards an efficient local confluence analysis of amalgamated graph transformation systems, we show that the analysis of a finite set of critical pairs suffices to prove local confluence.
 Erhan Leblebici, Anthony Anjorin, Andy Schürr, Gabriele
Taentzer:
MultiAmalgamated
Triple Graph Grammars.
International
Conference on Graph Transformation
Abstract.
Triple Graph Grammars (TGGs) are a wellknown technique for rulebased specification of bidirectional model transformation. TGG rules build up consistent models simultaneously and are operationalized automatically to forward and backward rules describing single transformation steps in the respective direction. These operational rules, however, are of fixed size and cannot describe transformation steps whose size can only be determined at transformation time for concrete models. In particular, transforming an element to arbitrary many elements depending on the transformation context is not supported. To overcome this limitation, we propose the integration of the multiamalgamation concept from classical graph transformation into TGGs. MultiAmalgamation formalizes the combination of multiple transformations sharing a common subpart to a single transformation. For TGGs, this enables repeating certain parts of a forward or backward transformation step in a for each looplike manner depending on concrete models at transformation time.
 Hendrik Radke, Thorsten Arendt,
Jan Steffen Becker, Annegret Habel, Gabriele
Taentzer:
Translating
Essential OCL Invariants to Nested Graph Constraints Focusing on Set
Operations.
International
Conference on Graph Transformation
Abstract.
Domainspecific modeling languages (DSMLs) are usually defined by metamodeling where invariants are defined in the Object Constraint Language (OCL). This approach is purely declarative in the sense that instance construction is not incorporated but has to added. In contrast, graph grammars incorporate the stepwise construction of instances by applying transformation rules. Establishing a formal relation between metamodeling and graph transformation opens up the possibility to integrate techniques of both fields. This integration can be advantageously used for optimizing DSML definition. Generally, a metamodel is translated to a type graph with a set of nested graph constraints. In this paper, we consider the translation of Essential OCL invariants to nested graph constraints. Building up on a translation of Core OCL invariants, we focus here on the translation of set operations. The main idea is to use the characteristic function of sets to translate set operations to corresponding Boolean operations. We show that a model satisfies an Essential OCL invariant iff its corresponding instance graph satisfies the corresponding nested graph constraint.
 Vlad Acretoiae, Harald Störrle, Daniel
Strüber:
Transparent Model
Transformation: Turning Your Favourite Model Editor into a
Transformation Tool.
International
Conference on Model Transformation
Abstract.
Current model transformation languages are supported by dedicated editors, often closely coupled to a single execution engine. We introduce Transparent Model Transformation, a paradigm enabling modelers to specify transformations using a familiar tool: their model editor. We also present VMTL, the first transformation language implementing the principles of Transparent Model Transformation: syntax, environment, and execution transparency. VMTL works by weaving a transformation aspect into its host modeling language. We show how our implementation of VMTL turns any model editor into a flexible model transformation tool sharing the model editor's benefits, transparently.
 Kristopher Born,
Thorsten Arendt,
Florian Heß, Gabriele
Taentzer:
Analyzing
Conflicts and Dependencies of RuleBased Transformations in
Henshin. (Extended
Version: Tool Demonstration)
Fundamental
Approaches to Software Engineering (FASE) 2015: 165168
Abstract.
Rulebased model transformation approaches show two kinds of nondeterminism: (1) Several rules may be applicable to the same model and (2) a rule may be applicable at several different matches. If two rule applications to the same model exist, they may be in conflict, i.e., one application may disable the other one. Furthermore, rule applications may enable others leading to dependencies. The critical pair analysis (CPA) can report all potential conflicts and dependencies of rule applications that may occur during model transformation processes. This paper presents the CPA integrated in Henshin, a model transformation environment based on the Eclipse Modeling Framework (EMF).
 Daniel Strüber,
Julia Rubin, Marsha Chechik, Gabriele
Taentzer:
A
VariabilityBased Approach to Reusable and Efficient Model
Transformations. (Extended
Version: Technical Report)
Fundamental
Approaches to Software Engineering (FASE) 2015: 283298
Abstract.
Large model transformation systems often contain transformation rules that are substantially similar to each other, causing performance bottlenecks for systems in which rules are applied nondeterministically, as long as one of them is applicable. We tackle this problem by introducing variabilitybased graph transformations. We formally define variabilitybased rules and contribute a novel matchfinding algorithm for applying them. We prove correctness of our approach by showing its equivalence to the classic one of applying the rules individually, and demonstrate the achieved performance speedup on a realistic transformation scenario.
 Anthony Anjorin, Erhan Leblebici, Andy Schürr, Gabriele Taentzer:
A Static Analysis of
NonConfluent Triple Graph Grammars for Efficient Model
Transformation. Awarded with the Best Paper
Award
Graph
Transformations (ICGT) 2014: 130145
Abstract.
Triple Graph Grammars (TGGs) are a wellknown bidirectional model transformation language. All actively developed TGG tools pose restrictions to guarantee efficiency (polynomial runtime), without compromising formal properties. Most tools demand confluence of the TGG, meaning that a choice between applicable rules can be freely made without affecting the final result of a transformation. This is, however, a strong restriction for transformations with inherent degrees of freedom that should not be limited at design time. eMoflon is a TGG tool that supports nonconfluent TGGs, allowing different results depending on runtime choices. To guarantee efficiency, nonetheless, a local choice of the next source element to be translated, based on source context dependencies of the rules, must not lead to a dead end, i.e., to a state where no rule is applicable for the currently chosen source element to be translated, and the transformation is not yet complete. Our contribution in this paper is to formalize a corresponding property, referred to as local completeness, using graph constraints. Based on the wellknown transformation of constraints to application conditions, we present a static analysis that guarantees dead endfreeness for nonconfluent TGGs.
 Thorsten Arendt, Annegret Habel, Hendrik Radke, Gabriele Taentzer:
From Core OCL
Invariants to Nested Graph Constraints. (Long
Version)
Graph
Transformations (ICGT) 2014: 97112
Abstract.
Metamodeling including the use of the Object Constraint Language (OCL) forms a wellestablished approach to design domainspecific modeling languages. This approach is purely declarative in the sense that instance construction is not needed and not considered. In contrast, graph grammars allow the stepwise construction of instances by the application of transformation rules. In this paper, we consider metamodels with Core OCL invariants and translate them to nested graph constraints for typed attributed graphs. Models and metamodels are translated to instance and type graphs. We show that a model satisfies a Core OCL invariant iff its corresponding instance graph satisfies the corresponding nested graph constraint. The aim of this work is to establish a first formal relation between metamodeling and the theory of graph transformation including constraints to come up with an integrated approach for defining modeling languages in an optimal way in the future.
 Steffen Vaupel, Gabriele Taentzer, Jan Peer Harries, Raphael Stroh, René Gerlach, Michael Guckert:
ModelDriven
Development of Mobile Applications Allowing RoleDriven
Variants.
International
Conference on Model Driven Engineering Languages and Systems (MODELS)
2014: 117
Abstract.
Rapidly increasing numbers of applications and users make the development of mobile applications one of the most promising fields in software engineering. Due to short timetomarket, differing platforms and fastly emerging technologies, mobile application development faces typical challenges where modeldriven development can help. We present a modeling language and an infrastructure for the modeldriven development (MDD) of Android apps supporting the specification of different app variants according to user roles. For example, providing users may continuously congure and modify custom content with one app variant whereas end users are supposed to use provided content in their variant. Our approach allows a flexible app development on different abstraction levels: compact modeling of standard app elements, detailed modeling of individual elements, and separate provider models for specific custom needs. We demonstrate our MDD approach at two apps: a phone book manager and a conference guide being configured by conference organizers for participants.
 Daniel G. Strüber, Michael Lukaszczyk, Gabriele Taentzer:
Tool Support for Model
Splitting using Information Retrieval and Model Crawling
Techniques.
Workshop on
Scalability in Model Driven Engineering (BigMDE) 2014: 4447
Abstract.
To facilitate the collaboration in largescale modeling scenarios, it is sometimes advisable to split a model into a set of submodels that can be maintained and analyzed independently. Existing automated approaches to model splitting, however, suffer from insufficient consideration of the stakeholder's intentions and add a significant overhead for comprehending the created decompositions. We present a new tool that aims to create more informed model decompositions by leveraging existing domain knowledge in the form of textual descriptions. From the user perspective, the tool comprises a textual editor for assembling the descriptions and a visual editor for reviewing and postprocessing the generated splitting suggestions. We preliminarily evaluate the tool in a case study involving a reallife model.
 Daniel Strüber,
Julia Rubin, Gabriele
Taentzer, Marsha Chechik:
Splitting
Models Using Information Retrieval and Model Crawling
Techniques.
Fundamental
Approaches to Software Engineering (FASE) 2014: 4762
Abstract.
In team environments, models are often shared and edited by multiple developers. To allow modularity and facilitate developer independence, we consider the problem of splitting a large monolithic model into submodels. We propose an approach that assists users in iteratively discovering the set of desired submodels. Our approach is supported by an automated algorithm that performs model splitting using information retrieval and model crawling techniques. We demonstrate the effectiveness of our approach on a set of reallife case studies, involving UML class models and EMF metamodels.
Quality Assurance of
Software Models  A Structured Quality Assurance Process Supported by a
Flexible Tool Environment in the Eclipse Modeling
Project.
Dissertation, PhilippsUniversität Marburg, 2014
Abstract.
The paradigm of modelbased software development (MBSD) has become
more and more popular since it promises an increase in the efficiency
and quality of software development. In this paradigm, software models
play an increasingly important role and software quality and quality
assurance consequently leads back to the quality and quality assurance
of the involved models.
The fundamental aim of this thesis is the definition of a structured
syntaxoriented process for quality assurance of software models that
can be adapted to projectspecific and domainspecific needs. It is
structured into two subprocesses: a process for the specification of
projectspecific model quality assurance techniques, and a process for
applying them on concrete software models within a MBSD project. The
approach concentrates on quality aspects to be checked on the abstract
model syntax and is based on quality assurance techniques model
metrics, smells, and refactorings wellknown from literature. So far,
these techniques are mostly considered in isolation only and therefore
the proposed process integrates them in order to perform model quality
assurance more systematically. Three example cases performing the
process serve as proofofconcept implementations and show its
applicability, its flexibility, and hence its usefulness.
Related to several issues concerning model quality assurance minor
contributions of this thesis are (1) the definition of a quality model
for model quality that consists of highlevel quality attributes and
lowlevel characteristics, (2) overviews on metrics, smells, and
refactorings for UML class models including structured descriptions of
each technique, and (3) an approach for composite model refactoring
that concentrates on the specification of refactoring
composition.
Since manually reviewing models is time consuming and error prone,
several tasks of the proposed process should consequently be automated.
As a further main contribution, this thesis presents a flexible tool
environment for model quality assurance which is based on the Eclipse
Modeling Framework (EMF), a common open source technology in
modelbased software development. The tool set is part of the Eclipse
Modeling Project (EMP) and belongs to the Eclipse incubation project
EMF Refactor which is available under the Eclipse public license (EPL).
The EMF Refactor framework supports both the model designer and the
model reviewer by obtaining metrics reports, by checking for potential
model deficiencies (called model smells) and by systematically
restructuring models using refactorings. The functionality of EMF
Refactor is integrated into standard treebased EMF instance editors,
graphical GMFbased editors as used by Papyrus UML, and textual editors
provided by Xtext. Several experiments and studies show the suitability
of the tools for supporting the techniques of the structured
syntaxoriented model quality assurance process.
 Florian Mantz:
Coupled
Transformations of Graph Structures applied to Model
Migration.
Dissertation, PhilippsUniversität Marburg, 2014
Abstract.
ModelDriven Engineering (MDE) is a relatively new paradigm in
software engineering that pursues the goal to master the increased
complexity of modern software products. While software applications
have been developed for a specific platform in the past, today they are
targeting various platforms and devices from classical desktop PCs to
smart phones. In addition, they interact with other applications. To
easier cope with these new requirements, software applications are
specified in MDE at a high abstraction level in so called models prior
to their implementation. Afterward, model transformations are used to
automate recurring development tasks as well as to generate software
artifacts for different runtime environments. Thereby, software
artifacts are not necessarily files containing program code, they can
also cover configuration files as well as machine readable input for
model checking tools. However, MDE does not only address software
engineering problems, it also raises new challenges.
One of these new challenges is connected to the specification of
modeling languages, which are used to create models. The creation of a
modeling language is a creative process that requires several
iterations similar to the creation of models. New requirements as well
as a better understanding of the application domain result in an
evolution of modeling languages over time. Models developed in an
earlier version of a modeling language often needs to be coadopted
(migrated) to language changes. This migration should be automated, as
migrating models manually is time consuming and errorprone. While
application modelers use adhoc solutions to migrate their models,
there is still a lack of theory to ensure welldefined migration
results.
This work contributes to a formalization of modeling language evolution
with corresponding model migration on the basis of algebraic graph
transformations that have successfully been used earlier as theoretical
foundations of model transformation. The goal of this research is to
develop a theory that considers the problem of modeling language
evolution with corresponding model migration on a conceptual level,
independent of a specific modeling framework.
A tool
environment for quality assurance based on the Eclipse Modeling
Framework.
Autom. Softw. Eng. 20(2): 141184 (2013)
Abstract.
The paradigm of modelbased software development has become more and more popular since it promises an increase in the efficiency and quality of software development. Following this paradigm, models become primary artifacts in the software development process. Therefore, software quality and quality assurance frequently leads back to the quality and quality assurance of the involved models. In our approach, we propose a model quality assurance process that can be adapted to projectspecific and domainspecific needs. This process is based on static model analysis using model metrics and model smells. Based on the outcome of the model analysis, appropriate model refactoring steps can be performed. In this paper, we present a tool environment conveniently supporting the proposed model quality assurance process. In particular, the presented tools support metrics reporting, smell detection, and refactoring for models being based on the Eclipse Modeling Framework, a widely used open source technology in modelbased software development.
 Florian Mantz, Gabriele
Taentzer, Yngve Lamo:
CoTransformation
of Type and Instance Graphs Supporting Merging of Types and
Retyping.
ECEASST
61 (2013)
Abstract.
Algebraic graph transformation is a wellknown rulebased approach to manipulate graphs that can be applied in several contexts. In this paper we use it in the context of modeldriven engineering. Graph transformation rules usually specify changes to only one graph per application, however there are use cases such as model coevolution where not only a single graph should be manipulated but also related ones. The cotransformation of type graphs together with their instance graphs has shown to be a promising approach to formalize model and metamodel coevolution. In this paper, we extend our earlier work on coevolution by allowing transformation rules that have less restrictions so that graph manipulations such as merging of types and retyping of graph elements are allowed.
 Daniel Strüber,
Matthias Selter, Gabriele
Taentzer:
Tool Support for
Clustering Large MetaModels.
Workshop on
Scalability in Model Driven Engineering (BigMDE) 2013: Paper No.
7
Abstract.
Evergrowing requirements, longterm evolution and modernization of software projects lead to metamodels of remarkable size, being difficult to comprehend and maintain. This paper presents a tool that supports the decomposition of a metamodel into clusters of model elements. Methods proposed in the research area of graph clustering, aiming at the desired properties of high cohesion and low coupling, have been integrated in the tool. The methods are customized not only to utilize the underlying graph structure, but also the semantic information given in metamodels. An evaluation of the tool is provided in terms of a case study.
 Daniel Strüber,
Gabriele
Taentzer, Stefan Jurack, Tim Schäfer:
Towards a
Distributed Modeling Process Based on Composite
Models.
Fundamental Approaches to Software Engineering (FASE) 2013:
620
Abstract.
The rising impact of software development in globally distributed teams strengthens the need for strategies that establish a clear separation of concerns in software models. Dealing with large, weakly modularized models and conflicting changes on interrelated models are typical obstacles to be witnessed. This paper proposes a structured process for distributed modeling based on the modularization technique provided by composite models with explicit interfaces. It provides a splitting activity for decomposing large models, discusses asynchronous and synchronous editing steps in relation to consistency management and provides a merge activity allowing the reuse of code generators. All main concepts of composite modeling are precisely defined based on category theory.
 Florian Mantz, Gabriele
Taentzer, Yngve Lamo:
Customizing
model migrations by rule schemes.
IWPSE 2013: 110
Abstract.
Modeldriven engineering (MDE) is a software engineering
discipline focusing on models as the primary artifacts in the software
development process while programs are mainly generated by means of
modeltocode transformations. In particular, modeling languages
tailored to specic application domains promise to increase the
productivity and quality of software development. Nevertheless due to
e.g. evolving requirements, modeling languages and their metamodels
evolve which means that existing models have to be migrated
correspondingly. In our approach, such coevolutions are specied as
related graph transformations ensuring welltyped model migration
results. Based on our earlier work on cotransformations, we now
consider the automatic deduction of migration rule schemes from given
metamodel evolution rules. Rule schemes form the basis for user
customizations on a high abstraction level. A rule scheme deduction
algorithm is presented and several customized migration schemes for
different coevolution examples are discussed.
 Gabriele
Taentzer, Claudia Ermel, Philip Langer, Manuel Wimmer:
A fundamental approach to model
versioning based on graph modifications: from theory to
implementation.
Software and
Systems Modeling (2012)
Abstract.
Meta modeling is a widespread technique to define visual languages, with the UML being the most prominent one. Despite several advantages of meta modeling such as ease of use, the meta modeling approach has a major disadvantage: It does not offer a direct means for generating its language elements. This disadvantage poses a severe limitation on certain applications. For example, when developing model transformations, it is desirable to have enough valid instance models available for largescale testing. Producing such a large set by hand is tedious. In the related problem of compiler testing, a string grammar together with a simple generation algorithm is typically used to produce words of the language automatically. In this paper, we formalize a restricted form of metamodels by type graphs with multiplicities and introduce instancegenerating graph grammars for creating instance graphs representing the abstract syntax structures of models. Thereby, a further step is taken to overcome the main deficit of the metamodeling approach.
Instance
Generation from Type Graphs with Arbitrary
Multiplicities.
ECEASST
47 (2012)
Abstract.
Meta modeling is a widespread technique to define visual languages, with the UML being the most prominent one. Despite several advantages of meta modeling such as ease of use, the meta modeling approach has a major disadvantage: It does not offer a direct means for generating its language elements. This disadvantage poses a severe limitation on certain applications. For example, when developing model transformations, it is desirable to have enough valid instance models available for largescale testing. Producing such a large set by hand is tedious. In the related problem of compiler testing, a string grammar together with a simple generation algorithm is typically used to produce words of the language automatically. In this paper, we formalize a restricted form of metamodels by type graphs with multiplicities and introduce instancegenerating graph grammars for creating instance graphs representing the abstract syntax structures of models. Thereby, a further step is taken to overcome the main deficit of the metamodeling approach.
 Stefan Jurack, Gabriele
Taentzer:
Transformation of Typed Composite Graphs with Inheritance and
Containment Structures.
Fundam. Inform. 118(12): 97134 (2012)
Abstract.
Modeldriven development (MDD) has become a promising trend in software engineering. The modeldriven development of highly complex software systems may lead to large models which deserve a modularization concept to enable their structured development in larger teams. Graphs are a natural way to represent the underlying structure of visual models. Typed graphs with inheritance and containment structures are well suited to describe the essentials of models based on the Eclipse Modeling Framework (EMF). Composite graphs can specify the logical distribution of EMF models and therefore, can form the conceptual basis for composite modeling in modeldriven development. This is done based on the formal foundation of distributed graphs. Moreover, this categorytheoretical foundation allows for the precise definition of consistent composite graph transformations satisfying all inheritance and containment conditions.
 Enrico Biermann, Claudia Ermel, Gabriele
Taentzer:
Formal foundation of consistent EMF model transformations by
algebraic graph transformation.
Software and
System Modeling 11(2): 227250 (2012)
Abstract.
Model transformation is one of the key activities in modeldriven software development. An increasingly popular technology to define modeling languages is provided by theEclipse Modeling Framework (EMF). Several EMF model transformation approaches have been developed, focusing on different transformation aspects. To validate model transformations with respect to functional behavior and correctness, a formal foundation is needed. In this paper, we define consistent EMF model transformations as a restricted class of typed graph transformations using node type inheritance. Containment constraints of EMF model transformations are translated to a special kind of graph transformation rules such that their application leads to consistent transformation results only. Thus, consistent EMF model transformations behave like algebraic graph transformations and the rich theory of algebraic graph transformation can be applied to these EMF model transformations to show functional behavior and correctness. Furthermore, we propose parallel graph transformation as a suitable framework for modeling EMF model transformations with multiobject structures. Rules extended by multiobject structures can specify a flexible number of recurring structures. The actual number of recurring structures is dependent on the application context of such a rule. We illustrate our approach by selected refactorings of simplified statechart models. Finally, we discuss the implementation of our concepts in a tool environment for EMF model transformations.
 Timo Kehrer, Udo Kelter, Gabriele
Taentzer:
Integrating the Specification and Recognition of Changes in
Models.
SoftwaretechnikTrends
32(2) (2012)
Abstract.
Modelbased software development has become a widely accepted approach in application domains where software is longliving and must be maintainable. Models are subject to continuous change and have many versions during their lifetime. The specication and recognition of changes in models is the key to understand and manage the evolution of a modelbased system. However, model transformation and model versioning tools currently available are based on lowlevel operations on models, which are sometimes incomprehensible for users. Thus, both classes of tools should be better integrated and extended to supporting highlevel edit operations, e.g. refactoring operations.
 Gabriele
Taentzer, Florian Mantz, Yngve Lamo:
Cotransformation
of Graphs and Type Graphs with Application to Model
Coevolution.
ICGT 2012: 326340
Abstract.
Metamodeling has become the key technology to define do–mainspecific modeling languages in modeldriven engineering. Since do–mainspecific modeling languages often change quite frequently, concepts are needed for the coordinated evolution of their metamodels as well as of their models, and possibly other related artifacts. In this paper, we present a new approach to the cotransformation of graphs and type graphs and show how it can be applied to model coevolution. This means that models are specified as graphs while model relations, especially typeinstance relations, are defined by graph morphisms specifying type conformance of models to their metamodels. Hence, metamodel evolution and accompanying model migrations are formally defined by cotransformations of instance and type graphs. In our approach, we clarify the type conformance of cotransformations, the completeness of instance graph transformations wrt. their type graph modifications, and the reflection of type graph transformations by instance graph transformations. Finally, we discuss strategies for automatically deducing instance graph transformation rules from given type graph transformations.
 Anthony Anjorin, Andy Schürr, Gabriele
Taentzer:
Construction
of Integrity Preserving Triple Graph Grammars.
Awarded with the Best Paper Award
ICGT 2012: 356370
Triple Graph Grammars (TGGs) are a rulebased technique of specifying a consistency relation over a source, correspondence, and target domain, which can be used for bidirectional model transformation. A current research challenge is increasing the expressiveness of TGGs by ensuring that global constraints in the involved domains are not violated by the transformation. Negative Application Conditions (NACs) can be used to enforce this property, referred to as schema compliance. In previous work, we have presented a polynomial control algorithm for integrity preserving TGGs, using NACs only to ensure schema compliance, meaning that, for efficiency reasons, the usage of NACs must be restricted appropriately. In this paper, we apply the wellknown translation of global constraints to application conditions for a given TGG and set of global constraints. We show that the derived set of NACs is indeed sufficient and necessary to ensure schema compliance, i.e., that the TGG together with the derived NACs is integrity preserving by construction.
 Andrea Corradini, Gabriele
Taentzer:
ICGT
2012 Doctoral Symposium.
ICGT 2012: 416
Abstract.
Given the success of the previous Doctoral Symposia of ICGT held in 2008 in Leicester and in 2010 in Twente, also this year a specific event of the International Conference on Graph Transformation was explicitly dedicated to Ph.D. students. The Doctoral Symposium consisted of a technical session dedicated to presentations by doctoral students, held during the main conference, giving them a unique opportunity to present their research project and to interact with established researchers of the graph transformation community and with other students.
 Stefan Jurack:
Composite Modeling
based on Distributed Graph Transformation and the Eclipse Modeling
Framework.
Dissertation, PhilippsUniversität Marburg, 2012
Abstract.
Modeldriven development (MDD) has become a promising trend in
software engineering for a number of reasons. Models as the key
artifacts help the developers to abstract from irrelevant details,
focus on important aspects of the underlying domain, and thus master
complexity. As software systems grow, models may grow as well and
finally become possibly too large to be developed and maintained in a
comprehensible way. In traditional software development, the complexity
of software systems is tackled by dividing the system into smaller
cohesive parts, socalled components, and let distributed teams work on
each concurrently. The question arises how this strategy can be applied
to modeldriven development.
The overall aim of this thesis is to develop a formalized
modularization concept to enable the structured and largely independent
development of interrelated models in larger teams. To this end, this
thesis proposes component models with explicit export and import
interfaces where exports declare what is provided while imports declare
what it needed. Then, composite model can be connected by connecting
their compatible export and import interfaces yielding socalled
composite models. Suitable to composite models, a transformation
approach is developed which allows to describe changes over the whole
composition structure.
From the practical point of view, this concept especially targets
models based on the Eclipse Modeling Framework (EMF). In the modeling
community, EMF has evolved to a very popular framework which provides
modeling and code generation facilities for Java applications based on
structured data models.
Since graphs are a natural way to represent the underlying structure of
visual models, the formalization is based on graph transformation.
Incorporated concepts according to distribution heavily rely on
distributed graph transformation introduced by Taentzer. Typed graphs
with inheritance and containment structures are well suited to describe
the essentials of EMF models. However, they also induce a number of
constraints like acyclic inheritance and containment which have to be
taken into account. The categorytheoretical foundation in this thesis
allows for the precise definition of consistent composite graph
transformations satisfying all inheritance and containment
conditions.
The composite modeling approach is shown to be coherent with the
development of tool support for composite EMF models and composite EMF
model transformation.
 Timo Kehrer, Udo Kelter, Gabriele Taentzer:
A rulebased approach to the semantic lifting of model differences in the context of model versioning.
ASE 2011: 163172
Abstract.
In modelbased software engineering, models are primary artifacts which
iteratively evolve and which are often developed in teams. Therefore,
comparison and merge tools for models are indispensable. These tools
must compare models in a technologydependent runtime representation
and will initially derive lowlevel changes, which can differ
considerably from userlevel editing commands. Lowlevel differences
are often incomprehensible and should be semantically lifted to the
level of editing operations. This transformation of differences depends
on the model type, supported editing operations, and user preferences;
thus specific transformers are needed, and building them is a
challenge. We present a rulebased approach to this problem: lowlevel
differences are represented based on the Eclipse Modeling Framework.
They are transformed into representations of editing operations using a
rulebased model transformation engine. The necessary transformation
rules are automatically derived from basic transformation rules for the
editing operations.
 Hartmut Ehrig, Claudia Ermel, Gabriele Taentzer:
A Formal Resolution Strategy for OperationBased Conflicts in Model Versioning Using Graph Modifications.
FASE 2011: 202216
Abstract.
In modeldriven engineering, models are primary artifacts and can
evolve heavily during their life cycle. Hence, versioning of models is
a key technique which has to be offered by an integrated development
environment for modeldriven engineering. In contrast to textbased
versioning systems, our approach takes abstract syntax structures in
model states and operational features into account. Considering the
abstract syntax of models as graphs, we define a model revision by a
span GDH, called graph modification, where G and H are the old and new
versions, respectively, and D the common subgraph that
remains unchanged. Based on notions of behavioural equivalence and
parallel independence of graph modifications, we are able to show a
LocalChurchRosser Theorem for graph modifications. The main goal of
the paper is to handle conflicts of graph modifications which may occur
in the case of parallel dependent graph modifications. The main result
is a general merge construction for graph modifications that resolves
all conflicts simultaneously in the sense that for deleteinsert
conflicts insertion has priority over deletion.
 Thorsten Arendt, Sieglinde Kranz, Florian Mantz, Nikolaus Regnat, Gabriele Taentzer:
Towards Syntactical
Model Quality Assurance in Industrial Software Development: Process
Definition and Tool Support.
Software Engineering
2011: 6374
Abstract.
The paradigm of modelbased software development has become more and
more popular, since it promises an increase in the efficiency and
quality of software development. Following this paradigm, models become
primary artifacts in the software development process where quality
assurance of the overall software product considerably relies on the
quality assurance of involved software models. In this paper, we
concentrate on the syntactical dimension of model quality which is
analyzed and improved by model metrics, model smells, and model
refactorings. We propose an integration of these model quality
assurance techniques in a predefined quality assurance process being
motivated by specific industrial needs. By means of a small case study,
we illustrate the model quality assurance techniques and discuss
Eclipsebased tools which support the main tasks of the proposed model
quality assurance process.
 Claudia Ermel, Jürgen Gall, Leen Lambers, Gabriele Taentzer:
Modeling
with Plausibility Checking: Inspecting Favorable and Critical Signs for
Consistency between Control Flow and Functional Behavior.
FASE 2011:
156170
Abstract.
UML activity diagrams are a widespread modelling technique to capture
behavioral aspects of system models. Usually, pre and postconditions
of activities are described in natural language and are not formally
integrated with the static domain model. Hence, early consistency
validation of activity models is difficult due to their semiformal
nature. In this paper, we use integrated behavior models that integrate
activity diagrams with object rules defining sets of actions in simple
activities. We formalize integrated behavior models using typed,
attributed graph transformation. It provides a basis for plausibility
checking by static conflict and causality detection between specific
object rules, taking into account their occurrence within the control
flow. This analysis leads to favorable as well as critical signs for
consistency of the integrated behavior model. Our approach is supported
by ActiGra, an Eclipse plugin for editing, simulating and analyzing
integrated behavior models. It visualizes favorable and critical signs
for consistency in a convenient way and uses the wellknown graph
transformation tool AGG for rule application as well as static conflict
and causality detection. We validate our approach by modeling a
conference scheduling system.
 Mats Per Erik Heimdahl, Gabriele Taentzer:
Guest editorial: special issue on selected topics in
automated software engineering  Specification mining and defect
detection.
Autom. Softw. Eng. 18(34): 225226 (2011)
No Abstract.

Thorsten Arendt, Florian Mantz, Gabriele Taentzer.
EMF
Refactor: Specification and Application of Model Refactorings within
the Eclipse Modeling Framework.
9th edition of the BENEVOL workshop, Lille, France.
(2010)
 Thorsten Arendt, Pawel Stepien, Gabriele Taentzer.
EMF Metrics:
Specification and Calculation of Model Metrics within the Eclipse
Modeling Framework.
9th edition of the BENEVOL workshop, Lille, France.
(2010)
 Thorsten Arendt, Matthias Burhenne, Gabriele Taentzer.
Defining and
Checking Model Smells: A Quality Assurance Task for Models based on the
Eclipse Modeling Framework.
9th edition of the BENEVOL workshop, Lille, France. (2010)
 David S. Rosenblum, Gabriele Taentzer:
Proceedings: Fundamental Approaches to Software Engineering,
13th International Conference, FASE 2010.
Held as Part of the Joint European Conferences on Theory and Practice
of Software, ETAPS 2010.
Paphos, Cyprus, March 2028, 2010.
Springer 2010

Enrico Biermann, Hartmut Ehrig, Claudia Ermel, Ulrike Golas, Gabriele Taentzer:
Parallel Independence of Amalgamated Graph Transformations
Applied to Model Transformation.
Graph Transformations and ModelDriven Engineering 2010
Abstract.
The theory of algebraic graph transformation has proven to be
a suitable underlying formal framework to reason about the behavior of
model transformations. In order to model an arbitrary number of actions
at different places in the same model, the concept of amalgamated graph
transformation has been proposed. Rule applications of certain
regularity are described by a rule scheme which contains multirules
modeling elementary actions and a common kernel rule for their
synchronization (amalgamation). The amalgamation theorem by Böhm et al.
ensures that for two multirules, the application of the amalgamated
rule yields the same result as two iterative rule applications,
respecting their common kernel rule application. In this paper, we
propose an extension of the amalgamation theorem to an arbitrary finite
number of synchronous rule applications. The theorem is used to show
parallel independence of amalgamated graph transformations by analyzing
the underlying multirules. As example, we specify an excerpt of a
model transformation from Business Process Models (BPM) to the Business
Process Execution Language (BPEL).
 Stefan Jurack and Gabriele Taentzer:
A Component Concept for Typed Graphs with Inheritance and
Containment Structures.
International Conference on
Graph Transformation (2010): 187202
Abstract.
Modeldriven development (MDD) has become a promising trend in software
engineering. The modeldriven development of highly complex software
systems may lead to large models which deserve a modularization concept
to enable their structured development in larger teams. Graphs are a
natural way to represent the underlying structure of visual models.
Typed graphs with inheritance and containment are well suited to
describe the essentials of models based on the Eclipse Modeling
Framework (EMF). EMF models already support the physical distribution
of model parts. Based on the concept of distributed graphs, we propose
typed composite graphs with inheritance and containment to specify
logical distribution structures of EMF models. The categorytheoretical
foundation of this kind of composite graphs forms a solid basis for the
precise definition of typed composite graph transformations obeying
inheritance and containment conditions.

Gabriele Taentzer, Claudia Ermel, Philip Langer, Manuel Wimmer:
Conflict Detection for Model Versioning Based on Graph
Modifications.
International Conference on
Graph Transformation (2010): 171186
Abstract.
In modeldriven engineering, models are primary artifacts and
can evolve heavily during their life cycle. Therefore, versioning of
models is a key technique which has to be offered by an integrated
development environment for modeldriven engineering. In contrast to
textbased versioning systems we present an approach which takes
abstract syntax structures in model states and operational features
into account. Considering the abstract syntax of models as graphs, we
define model revisions as graph modifications which are not necessarily
rulebased. Building up on the DPO approach to graph transformations,
we define two different kinds of conflict detection: (1) the check for
operationbased conflicts, and (2) the check for statebased conflicts
on results of merged graph modifications.
 Thorsten Arendt, Enrico Biermann, Stefan Jurack, Christian Krause, Gabriele Taentzer:
Henshin: Advanced Concepts and Tools for InPlace EMF Model
Transformations.
Model
Driven Engineering Languages and Systems Part I (2010):
121135
Abstract.
The Eclipse Modeling Framework (EMF) provides modeling and code
generation facilities for Java applications based on structured data
models. Henshin is a new language and associated tool set for inplace
transformations of EMF models. The Henshin transformation language uses
patternbased rules on the lowest level, which can be structured into
nested transformation units with welldefined operational semantics.
Socalled amalgamation units are a special type of transformation units
that provide a foralloperator for pattern replacement. For all of
these concepts, Henshin offers a visual syntax, sophisticated editing
functionalities, execution and analysis tools. The Henshin
transformation language has its roots in attributed graph
transformations, which offer a formal foundation for validation of EMF
model transformations. The transformation concepts are demonstrated
using two case studies: EMF model refactoring and metamodel
evolution.
 Enrico Biermann, Claudia Ermel, Gabriele Taentzer:
Lifting
Parallel Graph Transformation Concepts to Model Transformation based on
the Eclipse Modeling Framework.
Electronic
Communications of the EASST 26 (2010)
Abstract.
Model transformation is one of the key concepts in modeldriven
software development. An increasingly popular technology to define
modeling languages is provided by the Eclipse Modeling Framework (EMF).
Several EMF model transformation approaches have been developed,
focusing on different transformation aspects. This paper proposes
parallel graph transformation introduced by Ehrig and Kreowski as a
suitable framework for modeling EMF model transformations with
multiobject structures. Multiobject structures at transformation rule
level provide a convenient way to describe the transformation of
structures with a variable number of recurring structures, dependent on
concrete model instances. Parallel graph transformation means the
simultaneous application of a set of transformation rules synchronized
at the application of a kernel rule. We apply our extended EMF model
transformation technique to model the simulation of statecharts with
ANDstates.
 Claudia Ermel, Hartmut Ehrig, Fernando Orejas, Gabriele Taentzer:
International Colloquium on Graph and Model Transformation (GraMoT)
2010.
What
Algebraic Graph Transformations Can Do For Model
Transformations.
Electronic
Communications of the EASST 30 (2010)
Abstract.
Model transformations are key activities in modeldriven development
(MDD). A number of model transformation approaches have emerged for
different purposes and with different backgrounds.
This paper focusses on the use of algebraic graph transformation
concepts to specify and verify model transformations in MDD.

Enrico Biermann, Claudia Ermel, Leen Lambers, Ulrike Prange, Olga Runge, Gabriele Taentzer:
STTT 12(34): 245261 (2010)
Abstract.
In this paper, we focus on the Conference Scheduling
System, a case study at the Tool Contest ofGraphBased Tools
(GraBaTs) 2008. We took part in the contest with our graph
transformation tool AGG and the Eclipsebased EMF model transformation
tool EMF Tiger. We present the features of both tools and
evaluate their abilities to model the Conference Scheduling System and
to deal with additional contest assignments likemodel instance
generation, property verification, and interoperability.
 Thorsten Arendt, Florian Mantz, Lars Schneider and Gabriele Taentzer:
Model Refactoring in Eclipse by LTK, EWL, and EMF Refactor: A
Case Study
MoDSEMCCM 2009
Workshop.
Abstract. Since modeldriven
development (MDD) has evolved to a promising trend in software
development, models become the primary artifacts of the software
development process. To ensure high model quality, using appropriate
quality assurance techniques like model refactoring is an essential
task. So far, tool support for model refactoring is limited,
particularly for models using the Eclipse Modeling Framework (EMF). In
this paper we present the results of a case study that examines three
solutions for EMF model refactoring, namely the Language Toolkit (LTK),
the Epsilon Wizard Language (EWL) and EMF Refactor, a new approach in
the field of model refactoring.
 Stefan Jurack, Leen Lambers, Katharina Mehner, Gabriele Taentzer and Gerd Wierse:
Object Flow Definition for Refined Activity
Diagrams
FASE 2009: 4963, SpringerLink 2009  Springer
Berlin/Heidelberg.
Abstract. Activity diagrams are a
wellknown means to model the control flow of system behavior. Their
expressiveness can be enhanced by using their object flow notation. In
addition, we refine activities by pairs of pre and postconditions
formulated by interrelated object diagrams. To define a clear semantics
for refined activity diagram with object flow, we use a graph
transformation approach. Control flow is formalized by sets of
transformation rule sequences, while object flow is described by
partial dependencies between transformation rules. The theory of
algebraic graph transformation can be used to validate the consistency
of control and object flows in refined activity diagrams. This approach
is illustrated by a simple servicebased online university
calendar.
 Stefan Jurack and Gabriele Taentzer:
Towards Composite Model Transformations Using Distributed Graph
Transformation Concepts
MoDELS 2009: 226240.
Abstract. Modelbased development of
highly complex software systems leads to large models. Storing them in
repositories offers the possibility to work with these models in a
distributed environment. However, they are not modularized and thus, do
not especially support distributed development. An alternative is to
consider composite models such that several teams can work largely
independently. In this paper, we consider a general approach to
composite models and their transformation based on graph transformation
concepts. To illustrate this approach, we present a concrete setting
for composite models based on the Eclipse Modeling Framework (EMF). EMF
models can be distributed over several sites. While remote references
can express import relations, export and import interfaces are not
explicitly defined. In our approach, we sketch composite models with
explicit and implicit interfaces using concepts of distributed graph
transformation and outline different kinds of composite model
transformations.
 Jean Bézivin, Robert France, Martin Gogolla, Øystein Haugen, Gabriele Taentzer and Dániel Varró:
Teaching Modeling: Why, When, What?
MoDELS Workshops 2009: 5562.
Abstract. This paper reports on a
panel discussion held during the Educators’ Symposium at MODELS’2009.
It shortly explains the context provided for the discussion and
outlines the statements made by the panelists. The panelists were asked
to make their statements along a number of topics relevant to teaching
modeling like: Notation, Semantics, Programming, Tooling, Suitability,
Metamodeling.
 Karsten Ehrig, Jochen Malte Küster and Gabriele Taentzer:
Generating instance models from meta models
Software and System Modeling 8(4): 479500 (2009).
Abstract. Meta modeling is a
widespread technique to define visual languages, with the UML being
the most prominent one. Despite several advantages of meta modeling
such as ease of use, the meta modeling approach has one disadvantage:
it is not constructive, i.e., it does not offer a direct means of
generating instances of the language. This disadvantage poses a severe
limitation for certain applications. For example, when developing model
transformations, it is desirable to have enough valid instance models
available for largescale testing. Producing such a large set by hand
is tedious. In the related problem of compiler testing, a string
grammar together with a simple generation algorithm is typically used
to producewords of the language automatically. In this paper, we
introduce instancegenerating graph grammars for creating instances of
meta models, thereby overcoming the main deficit of the meta modeling
approach for defining languages.
 Katharina Mehner, Mattia Monga and Gabriele Taentzer:
Analysis of AspectOriented Model Weaving
Transitions on AspectOriented Software Development 5: 235263
(2009).
Abstract. Aspectoriented concepts
are currently exploited to model systems from the beginning of their
development. Aspects capture potentially crosscutting concerns and make
it easier to formulate desirable properties and to understand analysis
results than in a tangled system. However, the complexity of
interactions among different aspectualized entities may reduce the
benefit of aspectoriented separation of crosscutting concerns. Some
interactions may be intended or may be emerging behavior, while others
are the source of unexpected inconsistencies. It is therefore desirable
to detect inconsistencies as early as possible, preferably at the
modeling level. We propose an approach for analyzing interactions and
potential inconsistencies at the level of requirements modeling.We use
a variant of UML to model requirements in a usecase driven approach.
Activities that are used to refine usecases are the join points to
compose crosscutting concerns. The activities and their composition
are formalized using the theory of graph transformation systems, which
provides analysis support for detecting potential conflicts and
dependencies between rulebased transformations. This theory is used to
effectively reason about potential interactions and inconsistencies
caused by aspectoriented composition. The analysis is performed with
the graph transformation tool AGG in order to get a better
understanding of the potential behavior of the composed system. In
addition, the activity control flow of the aspect/base specification
and the composition operators are taken into account to identify the
relevant interactions.
 Hartmut Ehrig, Reiko Heckel, Grzegorz Rozenberg and Gabriele Taentzer (eds.):
 Leen Lambers, Stefan Jurack, Katharina Mehner, Olga Runge and Gabriele Taentzer:
Sufficient criteria for consistent behavior modeling with
refined activity diagrams: Long version
Technical Report 200811, Technische Universität Berlin, 2008.
Abstract. In use casedriven
approaches to requirements modeling, UML activity diagrams are a
widespread means for refining the functional view of use cases. Early
consistency validation of activity diagrams is therefore desirable but
difficult due to the semiformal nature of activity diagrams. In this
paper, we specify wellstructured activity diagrams and define
activities more precisely by pre and post conditions. They can be
modeled by interrelated pairs of object diagrams based on a domain
class diagram. This activity refinement is based on the theory of graph
transformation and paves the ground for a consistency analysis of the
required system behavior. A formal semantics for activity diagrams
refined by pre and postconditions allows us to establish sufficient
criteria for consistency. The semiautomatic checking of these criteria
is supported by a tool for graph transformation.
Construction of Consistent Models in ModelDriven Software
Development
RalfDetlef Kutsche and Nikola Milanovic (eds.)
ModelBased Software and Data Integration, First International
Workshop, MBSDI 2008, Berlin, Germany.
SpringerVerlag Berlin Heidelberg 2008, Communications in Computer and
Information Science.
Abstract. Modeldriven software
development is considered as a promising paradigm in software
engineering. Models are ideal means for abstraction and can enable
developers tomaster the increasing complexity of software systems.
However, it is not easy to construct consistent models. Inconsistent
models are usually the source for erroneous code which cannot be
compiled or, if compiled, lead to malfunctioning applications.
Developers have little help in producing consistent models, i.e. they
are often not well informed by adequate error messages. Starting with a
consistent initial model, we follow the idea to identify designated
model development steps between consistent models only. These
development steps are defined as model transformations. Recurring
modeling patterns are identified and formalized as transformation
rules. As essential contribution, a construction approach for
consistent models in modeldriven development is deduced and specified
on the basis of graph transformation concepts. Using this approach,
developers can be guided in the modeling process such that consistent
models are developed only.
 Gabor Karsai and Gabriele Taentzer:
Third
international workshop on graph and model
transformations
ICSE
Companion 2008: 10551056.
 Tom Mens, Dirk Müller and Gabriele Taentzer:
ModelDriven Software Refactoring
Jörg Rech and Christian Bunse (eds.):
ModelDriven Software Development: Integrating Quality Assurance, IGI
Global, 2008.
 Stefan Jurack, Leen Lambers, Katharina Mehner and Gabriele Taentzer:
Sufficient
Criteria for Consistent Behavior Modeling with Refined Activity
Diagrams
MoDELS 2008: 341355.
Abstract. In use casedriven
approaches to requirements modeling, UML activity diagrams are a
widespread means for refining the functional view of use cases. Early
consistency validation of activity diagrams is therefore desirable but
difficult due to the semiformal nature of activity diagrams. In this
paper, we specify wellstructured activity diagrams and define
activities more precisely by pre and postconditions. They can be
modeled by interrelated pairs of object diagrams based on a domain
class diagram. This activity refinement is based on the theory of graph
transformation and paves the ground for a consistency analysis of the
required system behavior. A formal semantics for activity diagrams
refined by pre and postconditions allows us to establish sufficient
criteria for consistency. The semiautomatic checking of these criteria
is supported by a tool for graph transformation.
 Enrico Biermann, Claudia Ermel and Gabriele Taentzer:
Precise Semantics of EMF Model Transformations by Graph
Transformation
MoDELS 2008: 5367.
Abstract. Model transformation is one
of the key activities in modeldriven software development. An
increasingly popular technology to define modeling languages is
provided by the Eclipse Modeling Framework (EMF). Several EMF model
transformation approaches have been developed, focusing on different
transformation aspects. To validate model transformations wrt.
functional behavior and correctness, a formal foundation is needed. In
this paper, we define EMF model transformations as a special kind of
typed graph transformations using node type inheritance. Containment
constraints of EMF model transformations are translated to a special
kind of EMF model transformation rules such that their application
leads to consistent transformation results only. Thus, we identify a
kind of EMF model transformations which behave like algebraic graph
transformations. As a consequence, the rich theory of algebraic graph
transformation can be applied to these EMF model transformations to
show functional behavior and correctness. We illustrate our approach by
selected refactorings of simplified statechart models.
 Leen Lambers, Hartmut Ehrig and Gabriele Taentzer:
Sufficient Criteria for Applicability and NonApplicability of
Rule Sequences
ECEASST 10 (2008).
Abstract. In several rulebased
applications using graph transformation as underlying modeling
technique the following questions arise: How can one be sure that a
specific sequence of rules is applicable (resp. not applicable) on a
given graph? Of course, it is possible to use a trial and error
strategy to find out the answer to these questions. In this paper
however, we will formulate suitable sufficient criteria for
applicability and other ones for nonapplicability. These criteria can
be checked in a static way i.e. without trying to apply the whole rule
sequence explicitly. Moreover if a certain criterion is not satisfied,
then this is an indication for reasons why rule sequences may or may
not be applicable. Consequently it is easier to rephrase critical rule
sequences. The results are formulated within the framework of double
pushout (DPO) graph transformations with negative application
conditions (NACs).
 Frank Hermann, Hartmut Ehrig and Gabriele Taentzer:
A Typed Attributed Graph Grammar with Inheritance for the
Abstract Syntax of UML Class and Sequence Diagrams
Electr. Notes Theor. Comput. Sci. 211: 261269 (2008).
Abstract. According to the UML
Standard 2.0 class and sequence diagrams are defined in a descriptive
way by a MOF metamodel and semiformal constraints. This paper
presents a formal and constructive definition of the abstract syntax of
UML class and sequence diagrams based on the welldefined theory of
typed attributed graph transformation with inheritance and application
conditions. The generated language covers all important features of
these parts of UML diagrams and is shown to satisfy all of the
corresponding constraints by construction. An explicit model
transformation demonstrates the close correspondence between the graph
grammar and the MOF definition of UML class and sequence diagrams. The
graph grammar is validated by wellestablished benchmarks showing that
all important features of the MOF definition of UML are covered. This
formal constructive syntax definition of UML class and sequence
diagrams is the basis for syntax directed editing, formal analysis,
formal operational and denotational semantics and correctness of model
transformations.
 Jessica Winkelmann, Gabriele Taentzer, Karsten Ehrig and Jochen Malte Küster:
Translation of Restricted OCL Constraints into Graph
Constraints for Generating Meta Model Instances by Graph
Grammars
Electr. Notes Theor. Comput. Sci. 211: 159170 (2008).
In Proc. International Workshop on Graph Transformation and Visual
Modeling Techniques (GTVMT'06), ENTCS, Vienna, Austria. Elsevier
Science.
Abstract. The meta modeling approach
to syntax definition of visual modeling techniques has gained wide
acceptance, especially by using it for the definition of UML. Based on
class structures and wellformedness rules, which could be formalized
by OCL, the abstract syntax of visual modeling techniques is defined in
a declarative way. Since metamodeling is nonconstructive, it does not
provide a systematic way available to generate all possible meta model
instances. But for example, when developing model transformations, it
is desirable to have a large set of valid instances at hand to perform
largescale testing. In our approach, an instancegenerating graph
grammar is automatically created from a given meta model. This graph
grammar ensures correct typing and cardinality constraints. To satisfy
also the given OCL constraints, wellformedness checks have to be done
in addition. As a first step, a restricted form of OCL constraints can
be translated to graph constraints which are to be checked during the
instance generation process.
 Paolo Bottoni, Francesco ParisiPresicce, Simone Pulcini, Gabriele Taentzer:
Maintaining Coherence Between Models With Distributed Rules:
From Theory to Eclipse
Electr. Notes Theor. Comput. Sci. 211: 8798 (2008).
Abstract. Integrated Development
Environments supporting software and model evolution have to deal with
the problem of maintaining coherence between code and model despite
changes which may occur on both sides. Rather than going through model
reengineering or code regeneration, it would be better to build a full
correspondence between the starting models and keep it updated in an
incremental way after each evolutionary step. In a series of previous
papers, it was shown how distributed graph rewriting could support such
updates. Here, we show how to construct a distributed graph from
individual models, through the use of synchronized rules. In
particular, we discuss the case of Java code and UML models, and
propose an Eclipse implementation of the approach.
 Enrico Biermann, André Crema, Karsten Ehrig, Claudia Ermel, Christian Köhler, René Schmutzler and Gabriele Taentzer:
Extending GMF: Generating DomainSpecific Model Editors with Complex
Editing Commands
Eclipse Summit Europe 2007: The Modeling Symposium.
 Katharina Mehner, Mattia Monga and Gabriele Taentzer:
Analysis of AspectOriented Model Weaving
SpringerLink 2007  Springer Berlin/Heidelberg , 03029743 (Print),
16113349 (Online), Volume 5490/2009.
Abstract. Aspectoriented concepts
are currently exploited to model systems from the beginning of their
development. Aspects capture potentially crosscutting concerns and make
it easier to formulate desirable properties and to understand analysis
results than in a tangled system. However, the complexity of
interactions among different aspectualized entities may reduce the
benefit of aspectoriented separation of crosscutting concerns. Some
interactions may be intended or may be emerging behavior, while others
are the source of unexpected inconsistencies. It is therefore desirable
to detect inconsistencies as early as possible, preferably at the
modeling level. We propose an approach for analyzing interactions and
potential inconsistencies at the level of requirements modeling. We use
a variant of UML to model requirements in a usecase driven approach.
Activities that are used to refine usecases are the join points to
compose crosscutting concerns. The activities and their composition
are formalized using the theory of graph transformation systems, which
provides analysis support for detecting potential conflicts and
dependencies between rulebased transformations. This theory is used to
effectively reason about potential interactions and inconsistencies
caused by aspectoriented composition. The analysis is performed with
the graph transformation tool AGG in order to get a better
understanding of the potential behavior of the composed system. In
addition, the activity control flow of the spect/base specification and
the composition operators are taken into account to identify the
relevant interactions.
 Gabriele Taentzer, Dirk Müller, Tom Mens:
Specifying
DomainSpecific Refactorings for AndroMDA Based on Graph
Transformation
AGTIVE 2007: 104119.
Abstract. Applying refactoring in a
modeldriven software engineering context raises many new challenges
that need to be addressed. In this paper, we consider modeldriven
software development based on the code generation framework AndroMDA.
Considering the UML profile for AndroMDA, we come up with a number of
domainspecific model refactorings. In its most recent version, the
AndroMDA code generation can be based on the Eclipse Modeling Framework
(EMF) which has evolved towards the de facto standard technology to
specify UML models. We show how domainspecific refactorings can be
specified by EMF transformation incorporating graph transformation
concepts. This opens up the possibility to reason about domainspecific
refactorings in a formal way.
 Arend Rensink, Alexander Dotor, Claudia Ermel, Stefan Jurack, Ole Kniemeyer, Juan de Lara, Sonja Maier, Tom Staijen, Albert Zündorf, Gabriele Taentzer:
Ludo: A Case Study for Graph Transformation
Tools
AGTIVE 2007: 493513.
Abstract. In this paper we describe
the Ludo case, one of the case studies of the AGTIVE 2007 Tool Contest.
After summarising the case description, we give an overview of the
submitted solutions. In particular, we propose a number of dimensions
along which choices had to be made when solving the case, essentially
setting up a solution space; we then plot the spectrum of solutions
actually encountered into this solution space. In addition, there is a
brief description of the special features of each of the submissions,
to do justice to those aspects that are not distinguished in the
general solution space.
 Arend Rensink and Gabriele Taentzer:
AGTIVE 2007 Graph Transformation Tool
Contest
AGTIVE 2007: 487492.
Abstract. In this short paper we
describe the setup and results of a new initiative to compare graph
transformation tools, carried out as part of the AGTIVE 2007 symposium
on “Applications of Graph Transformation with Industrial Relevance”.
The initiative took the form of a contest, consisting of two rounds:
the first round was a call for cases, the second round a call for
solutions. The response to both rounds was very good, leading to the
conclusion that this is an initiative worth repeating. There are,
however, a number of lessons to be learned; these are summarised here,
in order to improve the organisation and the eventual benefits of this
type of contest.
 Gabriele Taentzer, Enrico Biermann, Dénes Bisztray, Bernd Bohnet, Iovka Boneva, Artur Boronat, Leif Geiger, Rubino Geiß, Ákos Horvath, Ole Kniemeyer, Tom Mens, Benjamin Ness, Detlef Plump and Tamás Vajk:
Generation of Sierpinski Triangles: A Case Study for Graph
Transformation Tools
AGTIVE 2007: 514539.
Abstract. In this paper, we consider
a large variety of solutions for the generation of Sierpinski
triangles, one of the case studies for the AGTIVE graph transformation
tool contest. A Sierpinski triangle shows a wellknown fractal
structure. This case study is mostly a performance benchmark, involving
the construction of all triangles up to a certain number of iterations.
Both time and space performance are involved. The transformation rules
themselves are quite simple.
 Enrico Biermann, Karsten Ehrig, Claudia Ermel, Christian Köhler and Gabriele Taentzer:
The EMF Model Transformation Framework
AGTIVE 2007: 566567.
Abstract. The Eclipse Modeling
Framework (EMF) provides a modeling and code generation framework for
Eclipse applications based on structured data models. The goal of the
EMF Model Transformation framework (EMFTrans) is to support the
modification of EMF models based on graphical EMF model transformation
rules. EMFTrans currently consists of three components: a graphical
editor for EMF model transformation rules, a compiler, generating Java
code from these rules to be used in further projects, and an
interpreter for the execution of the rules using AGG, a graph
transformation tool environment.
 Enrico Biermann, Karsten Ehrig, Claudia Ermel and Gabriele Taentzer:
Generating Eclipse Editor PlugIns Using
Tiger
AGTIVE 2007: 583584.
Abstract. We present Tiger, a visual
environment to design visual language (VL) specifications based on meta
models, graph grammars and layout definitions. A VL specification
serves as basis to generate a visual editor for VL diagrams as Eclipse
plugin based on the Eclipse Graphical Editing Framework (GEF).
 Gabriele Taentzer, André Crema, René Schmutzler and Claudia Ermel:
Generating DomainSpecific Model Editors with Complex Editing
Commands
AGTIVE 2007: 98103.
Abstract. Domain specific modeling
languages are of increasing importance for the development of software
and other systems. Meta tools are needed to support rapid development
of domainspecific solutions. Using the Eclipse Graphical Modeling
Framework (GMF), modeling languages are defined by providing a meta
model using the MOF/EMF approach. Up to now, GMF provides basic editing
commands only. It does not support the definition of complex editing
commands which would allow e.g. to insert a complex structure into a
diagram in one step. As practical tool support for the design and
generation of visual editors with complex editing operations based on
graph transformation, an extended version of GMF has been developed and
is presented in this paper.
 Hartmut Ehrig, Karsten Ehrig, Claudia Ermel, Frank Hermann and Gabriele Taentzer:
Information
Preserving Bidirectional Model Transformations
FASE 2007: 7286.
Abstract. Within modeldriven
software development, model transformation has become a key activity.
It refers to a variety of operations modifying a model for various
purposes such as analysis, optimization, and code generation. Most of
these transformations need to be bidirectional to e.g. report analysis
results, or keep coherence between models. In several
applicationoriented papers it has been shown that triple graph
grammars are a promising approach to bidirectional model
transformations. But up to now, there is no formal result showing under
which condition corresponding forward and backward transformations are
inverse to each other in the sense of information preservation. This
problem is solved in this paper based on general results for the theory
of algebraic graph transformations. The results are illustrated by a
transformation of class models to relational data base models which has
become a quasistandard example for model transformation.
 Christian Köhler, Holger Lewin and Gabriele Taentzer:
Ensuring Containment Constraints in Graphbased Model Transformation
Approaches
ECEASST 6: (2007).
Abstract. Within model driven
software development, model transformation has become a key activity. A
couple of transformation approaches for metamodeldefined modeling
languages have been developed in the past years and are going to be
established in research and industry. None of these have made it to a
standard yet. There is a demand for correct model transformation in
various senses. Formal methods are helpful for showing correctness
issues of model transformations. As one approach, graph transformation
has been applied to the field of model transformation and are a
perspective for achieving provable correct model transformations. We
show in this paper, that containment associations as proposed by the
OMG are an integral part of MOFbased languages and imply a couple of
constraints which must be ensured in model transformation approaches.
Based on a doublepushout approach for graph transformation, conditions
are stated that ensure these containment constraints. This is an
important step for achieving formal transformation semantics for
modeling languages based on MOF, or specifically EMF.
 Tom Mens, Gabriele Taentzer and Olga Runge:
Analysing refactoring dependencies using graph
transformation
Software
and System Modeling 6 (3): 269285 (2007), Springer.
Abstract. Refactoring is a widely
accepted technique to improve the structure of objectoriented
software. Nevertheless, existing tool support remains restricted to
automatically applying refactoring transformations. Deciding what to
refactor and which refactoring to apply still remains a difficult
manual process, due to the many dependencies and interrelationships
between relevant refactorings. In this paper, we represent refactorings
as graph transformations, and we propose the techniques of critical
pair analysis and sequential dependency analysis to detect the implicit
dependencies between refactorings. The results of this analysis can
help the developer to make an informed decision of which refactoring is
most suitable in a given context and why. We report on several
experiments we carried out in the AGG graph transformation tool to
support our claims.
 Don Batory, Oscar Diaz, Hartmut Ehrig, Claudia Ermel, Ulrike Prange and Gabriele Taentzer:
Model Transformations Should be Functors
Bulletin of the EATCS, 92: 75–81, 2007.
Abstract. The concept of model
transformations is of increasing importance in different areas of
Computer Science, but up to now, there is a lack of common
understanding concerning the mathematical and practical point of view.
In this paper, we discuss some of the different aspects. Especially
interesting is the new proposal of the POPL’07 keynote speaker Don
Batory claiming that model transformations should be functors. This
claim is compared with different mathematical concepts of model
transformation.
 Juan de Lara, Roswitha Bardohl, Hartmut Ehrig, Karsten Ehrig, Ulrike Prange and Gabriele Taentzer:
Attributed graph transformation with node type
inheritance
Theor. Comput. Sci. 376 (3): 139163 (2007).
Abstract. The aim of this paper is to
integrate typed attributed graph transformation with node type
inheritance. Borrowing concepts from object oriented systems, the main
idea is to enrich the attributed type graph with an inheritance
relation and a set of abstract nodes. In this way, a node type inherits
the attributes and edges of all its ancestors. Based on these concepts,
it is possible to define abstract productions, containing abstract
nodes. These productions are equivalent to a number of concrete
productions, resulting from the substitution of the abstract node types
by the node types in their inheritance clan. Therefore, productions
become more compact and suitable for their use in combination with
metamodelling. The main results of this paper show that attributed
graph transformation with node type inheritance is fully compatible
with the existing concept of typed attributed graph transformation.
 Karsten Ehrig, Gabriele Taentzer and Dániel Varró:
Tool integration by model transformations based on the Eclipse Modeling
Framework
EASST Newsletter, 12, June 2006.
Abstract. In
the paper, we propose various approaches for tool integration based on
model transformations over the Eclipse Modeling Framework (EMF). EMF is
a key technology for tool integration, which provides a framework for
developing domainspecific modeling languages by automatically
generating Java code for model manipulation. Model transformations can
be captured by graph transformation systems, which support visual
specifications based on rules and patterns. Three levels of tool
integration are identified: (i) modellevel integration carries out
model transformations in existing transformation tools by importing and
exporting EMF models, (ii) interpreted EMF transformations take an EMF
model of the transformation system, and manipulate EMF models according
to the system by calling EMF interfaces, finally (iii) compiled
transformer plugins generate standalone transformer programs in Java
which are responsible for model manipulation.
 Dániel Varró, Szilvia VarróGyapay, Hartmut Ehrig, Ulrike Prange and Gabriele Taentzer:
Termination Analysis of Model Transformations by Petri
Nets
Proc.
Third International Conference on Graph Transformation (ICGT'06),
volume 4178 of LNCS, pages 260–274, Natal, Brazil, September 2006.
Springer.
Abstract. Despite the increasing
relevance of model transformation techniques in modeldriven software
development, research is mainly conducted to the specification and the
automation of such transformations. However, since the transformations
themselves may also contain conceptual flaws, it is essential to
formally analyze them prior to executing them on user models. In the
current paper, we focus on a central validation problem of trusted
model transformations, namely, termination and propose a Petri net
based analysis method that provides a sufficient criterion for the
termination problem of model transformations captured by graph
transformation systems.
 Enrico Biermann, Karsten Ehrig, Christian Köhler, Günter Kuhns, Gabriele Taentzer and Eduard Weiss:
EMF Model Refactoring based on Graph Transformation
Concepts
Proc. Third International Workshop on Software Evolution through
Transformations (SETra'06), volume3, Natal, Brazil, September 2006,
Electronic Communications of the EASST.
Abstract. The Eclipse Modeling
Framework (EMF) provides a modeling and code generation framework for
Eclipse applications based on structured data models. Within model
driven software development based on EMF, refactoring of EMF models
become a key activity. In this paper, we present an approach to define
EMF model refactoring methods as transformation rules being applied in
place on EMF models. Performing an EMF model refactoring, EMF
transformation rules are applied and can be translated to corresponding
graph transformation rules, as in the graph transformation environment
AGG. If the resulting EMF model is consistent, the corresponding result
graph is equivalent and can be used for validating EMF model
refactoring. Results on conflicts and dependencies of refactorings for
example, can help the developer to decide which refactoring is most
suitable for a given model and why.
 Enrico Biermann, Karsten Ehrig, Christian Köhler, Günter Kuhns, Gabriele Taentzer and Eduard Weiss:
Graphical Definition of InPlace Transformations in the Eclipse
Modeling Framework
Proc. 9th International Conference on Model Driven Engineering
Languages and Systems (MoDELS'06), Genova, Italy, October
2006.
Abstract. The Eclipse Modeling
Framework (EMF) provides a modeling and code generation framework for
Eclipse applications based on structured data models. Although EMF
provides basic operations for modifying EMF based models, a framework
for graphical definition of rulebased modification of EMF models is
still missing. In this paper we present a framework for inplace EMF
model transformation based on graph transformation. Transformations are
visually defined by rules on object patterns typed over an EMF core
model. Defined transformation systems can be compiled to Java code
building up on generated EMF classes. As running example different
refactoring methods for Ecore models are considered.
 Paolo Bottoni, Francesco ParisiPresicce, Simone Pulcini and Gabriele Taentzer:
Maintaining Coherence between Models with Distributed Rules:
from Theory to Eclipse
In Proc. International Workshop on Graph Transformation and Visual
Modeling Techniques (GTVMT'06), ENTCS, Vienna, Austria, April 2006.
Elsevier Science
Abstract. Integrated Development
Environments supporting software and model evolution have to deal with
the problem of maintaining coherence between code and model despite
changes which may occur on both sides. Rather than going through model
reingeneering or code regeneration, it would be better to build a full
correspondence between the starting models and keep it updated in an
incremental way after each evolutionary step. In a series of previous
papers, it was shown how distributed graph rewriting could support such
updates. Here, we show how to construct a distributed graph from
individual models, through the use of synchronized rules. In
particular, we discuss the case of Java code and UML models, and
propose an Eclipse implementation of the approach.
 Hartmut Ehrig, Karsten Ehrig, Ulrike Prange and Gabriele Taentzer:
Fundamental Theory for Typed Attributed Graphs and Graph
Transformation based on Adhesive HLR Categories
Fundamenta Informaticae, 74(1):31–61, 2006.
Abstract. The concept of typed
attributed graphs and graph transformation is most significant for
modeling and meta modeling in software engineering and visual
languages, but up to now there is no adequate theory for this important
branch of graph transformation. In this article we give a new
formalization of typed attributed graphs, which allows node and edge
attribution. The first main result shows that the corresponding
category is isomorphic to the category of algebras over a specific kind
of attributed graph structure signature. This allows to prove the
second main result showing that the category of typed attributed graphs
is an instance of ”adhesive HLR categories”. This new concept combines
adhesive categories introduced by Lack and Soboci´nski with the
wellknown approach of highlevel replacement (HLR) systems using a new
simplified version of HLR conditions. As a consequence we obtain a
rigorous approach to typed attributed graph transformation providing as
fundamental results the Local ChurchRosser, Parallelism, Concurrency,
Embedding and Extension Theorem and a Local Confluence Theorem known as
Critical Pair Lemma in the literature.
 Hartmut Ehrig, Karsten Ehrig, Ulrike Prange and Gabriele Taentzer:
Fundamentals
of Algebraic Graph Transformation
EATCS Monographs in Theoretical Computer Science. Springer, 2006.
Abstract. Graphs are widely used to
represent structural information in the form of objects and connections
between them. Graph transformation is the rulebased manipulation of
graphs, an increasingly important concept in computer science and
related fields. This is the first textbook treatment of the algebraic
approach to graph transformation, based on algebraic structures and
category theory. Part I is an introduction to the classical case of
graph and typed graph transformation. In Part II basic and advanced
results are first shown for an abstract form of replacement systems,
socalled adhesive highlevel replacement systems based on category
theory, and are then instantiated to several forms of graph and Petri
net transformation systems. Part III develops typed attributed graph
transformation, a technique of key relevance in the modeling of visual
languages and in model transformation. Part IV contains a practical
case study on model transformation and a presentation of the AGG
(attributed graph grammar) tool environment. Finally the appendix
covers the basics of category theory, signatures and algebras. The book
addresses both research scientists and graduate students in computer
science, mathematics and engineering.
 Karsten Ehrig, Jochen Malte Küster, Gabriele Taentzer and Jessica Winkelmann:
Generating Instance Models from Meta Models
8th IFIP International Conference on Formal Methods for Open
ObjectBased Distributed Systems (FMOODS'06), Bologna, Italy, June
2006.
Abstract. Meta modeling is a
widespread technique to define visual languages, with the UML being
the most prominent one. Despite several advantages of meta modeling
such as ease of use, the meta modeling approach has one disadvantage:
It is not constructive i. e. it does not offer a direct means of
generating instances of the language. This disadvantage poses a severe
limitation for certain applications. For example, when developing model
transformations, it is desirable to have enough valid instance models
available for largescale testing. Producing such a large set by hand
is tedious. In the related problem of compiler testing, a string
grammar together with a simple generation algorithm is typically used
to produce words of the language automatically. In this paper, we
introduce instancegenerating graph grammars for creating instances of
meta models, thereby overcoming the main deficit of the meta modeling
approach for defining languages.
 Karsten Ehrig, Gabriele Taentzer and Dániel Varró:
Tool integration by model transformations based on the eclipse
modeling framework
EASST Newsletter, 12, June 2006.
Abstract. In the paper, we propose
various approaches for tool integration based on model transformations
over the Eclipse Modeling Framework (EMF). EMF is a key technology for
tool integration, which provides a framework for developing
domainspecific modeling languages by automatically generating Java
code for model manipulation. Model transformations can be captured by
graph transformation systems, which support visual specifications based
on rules and patterns. Three levels of tool integration are identified:
(i) modellevel integration carries out model transformations in
existing transformation tools by importing and exporting EMF models,
(ii) interpreted EMF transformations take an EMF model of the
transformation system, and manipulate EMF models according to the
system by calling EMF interfaces, finally (iii) compiled transformer
plugins generate standalone transformer programs in Java which are
responsible for model manipulation.
 Claudia Ermel, Karsten Ehrig, Gabriele Taentzer and Eduard Weiss:
Object Oriented and Rulebased Design of Visual Languages using
TIGER
Proc. Third International Workshop on GraphBased Tools (GraBaTs'06),
volume1, Natal, Brazil, September 2006, Electronic Communications of
the EASST.
Abstract. In this paper we present
the stateoftheart of the TIGER environment for the generation of
visual editor plugins in Eclipse, with the focus on its Designer
component, a visual environment for object oriented and rulebased
design of visual languages. Based on an alphabet for finite automata we
show how a visual language can be designed by defining the abstract and
concrete syntax of the visual language and syntax directed editing
operations in the generated editor plugin. For the graphical layout we
use the Graphical Editing Framework (GEF) of ECLIPSE which offers an
efficient and standardized way for graphical layouting.
 Frank Hermann, Hartmut Ehrig and Gabriele Taentzer:
A typed attributed Graph Grammar with Inheritance for the
Abstract Syntax of UML Class and Sequence Diagrams
In Proc. International Workshop on Graph Transformation and Visual
Modeling Techniques (GTVMT'06), ENTCS, Vienna, Austria, April 2006.
Elsevier Science.
Abstract. According to the UML
Standard 2.0 class and sequence diagrams are defined in a descriptive
way by a MOF metamodel and semiformal constraints. This paper
presents a formal and constructive definition of the abstract syntax of
UML class and sequence diagrams based on the welldefined theory of
typed attributed graph transformation with inheritance and application
conditions. The generated language covers all important features of
these parts of UML diagrams and is shown to satisfy all of the
corresponding constraints by construction. An explicit model
transformation demonstrates the close correspondence between the graph
grammar and the MOF definition of UML class and sequence diagrams. The
graph grammar is validated by wellestablished benchmarks showing that
all important features of the MOF definition of UML are covered. This
formal constructive syntax definition of UML class and sequence
diagrams is the basis for syntax directed editing, formal analysis,
formal operational and denotational semantics and correctness of model
transformations.
 Susanne JucknathJohn, Dennis Graf and Gabriele Taentzer:
Evolutionary
layout: preserving the mental map during the development of class
models
SOFTVIS 2006: 165166.
 Susanne JucknathJohn, Dennis Graf, Gabriele Taentzer:
Evolutionary Layout of Graph Transformation
Sequences
In Proc. Third International Workshop on GraphBased Tools
(GraBaTs'06), volume 1, Natal, Brazil, September 2006. Electronic
Communications of the EASST.
Abstract. The paper presents an evolutionary layout algorithm of graph transformation sequences which is based on the wellknown spring embedder layout algorithm. The spring embedder algorithm already fulfills two important requirements for layouting a graph sequence: the highest single layout quality and the lowest difference between two successive layouts. But this layout algorithm does not fit well for incomplete graph sequences, since the following two new requirements are not fulfilled: 1. the option for future extensions of graph sequences without ruining the layout, 2. by taking also typing of graph edges into account. So we extended the spring embedder layout algorithm by two new concepts: 1. A concept of node ageing and protection of senior node positions in the layout that allows the user to keep track of changes during transformation steps. The persistence of node positions throughout a sequence is most helpful to preserve the mental map. Especially the concept of ageing was the reason to name the algorithm an evolutionary layout algorithm. 2. A concept of layout patterns based on edge typing. This new layout algorithm tries to solve the following problems for an evolving graph transformation sequence: 1. The quality of every single layout should be as optimal as possible. 2. The mental distance from one layout to its successor layout should be small. 3. The graph sequence may have future extensions, without loosing the layout`s quality. 4. The changes between two graphs should be easily recognizable in the layout of two subsequent graphs.
 Katharina Mehner, Mattia Monga and Gabriele Taentzer:
Interaction Analysis in AspectOriented
Models
Proc.
14th IEEE International Requirements Engineering Conference, pages
66–75, Minneapolis, Minnesota, USA, September 2006. IEEE Computer
Society.
Abstract. Aspectoriented concepts
are currently introduced in all phases of the software development life
cycle. However, the complexity of interactions among different aspects
and between aspects and base entities may reduce the value of
aspectoriented separation of crosscutting concerns. Some interactions
may be intended or may be emerging behavior while others are the source
of unexpected inconsistencies. Thus, it is desirable to detect
inconsistencies as early as possible, preferably at the modeling level.
We propose an approach for analyzing interactions and potential
inconsistencies at the level of requirements modeling. We use a variant
of UML to model requirements in a usecase driven approach. Activities,
which are used to refine use cases, are the join points to compose
crosscutting concerns. The activities and their composition are
formalized by using the theory of graph transformation systems, which
provides analysis support for the detection of potential conflicts and
dependencies between rulebased transformations. This theory is used to
effectively reason about potential interactions and inconsistencies
caused by aspectoriented composition. The analysis is performed with
the graph transformation tool AGG. The automatically analyzed conflicts
and dependencies also serve as an additional view that helps in better
understanding the potential behavior of the composed system.
 Tom Mens, Gabriele Taentzer and Olga Runge:
Analysing refactoring dependencies using graph
transformation
Software
and System Modeling, 2006
Abstract. Refactoring is a widely
accepted technique to improve the structure of objectoriented
software. Nevertheless, existing tool support remains restricted to
automatically applying refactoring transformations. Deciding what to
refactor and which refactoring to apply still remains a difficult
manual process, due to the many dependencies and interrelationships
between relevant refactorings. In this paper, we represent refactorings
as graph transformations, and we propose the techniques of critical
pair analysis and sequential dependency analysis to detect the implicit
dependencies between refactorings. The results of this analysis can
help the developer to make an informed decision of which refactoring is
most suitable in a given context and why. We report on several
experiments we carried out in the AGG graph transformation tool to
support our claims.
 Gabriele Taentzer and Giovanni Toffetti Carughi:
A graphbased approach to transform XML
documents
In Luciano Baresi and Reiko Heckel (eds.)
Proc.
Fundamental Approaches to Software Engineering (FASE), volume 3922 of
LNCS, Springer, 2006.
Abstract. As XML diffusion keeps
increasing, it is today common practice for most developers to deal
with XML parsing and transformation. XML is used as format to e.g.
render data, query documents, deal with Web services, generate code
from a model or perform model transformation. Nowadays XSLT is the most
common language for XML transformation. But, although meant to be
simple, coding in XSLT can become quite a challenge, if the coding
approach does not only depend on the structure of the source document,
but the order of template application is also dictated by target
document structure. This is the case especially when dealing with
transformations between visual models. We propose to use a graphbased
approach to simplify the transformation definition process where graphs
representing documents are transformed in a rulebased manner, as in
XSLT. The differences to XSLT are mainly that rules can be developed
visually, are more abstract (since the order of execution does not
depend on the target document), IDREFs are dealt with much more
naturally, and due to typed transformations, the output document is
guaranteed to be valid with respect to the target schema. Moreover,
graphbased transformation definitions can be automatically reversed in
most cases. This is especially useful in model transformation (e.g. in
OMG's MDA approach).
 Gabor Karsai, Gabriele Taentzer:
Preface to GraMoT 2006 Workshop Proceedings
ECEASST 4: (2006).
Characterizing Tools for Visual Modeling
Techniques
Karsten Ehrig, Reiko Heckel and Georgios Lajios (eds.)
Lecture Notes of SegraVis Advanced School on Visual Modelling
Techniques, Leicester, UK, September 2006.
Abstract. In the wide area of visual
modeling techniques a large number of CASE and MetaCASE tools have
been developed to define and work with visual modeling techniques. In
this report, we mainly concentrate on those tools developed by partners
and grant holders of the Research Training Network SegraVis on
Syntactic and Semantic Integration of Visual Modeling Techniques. Each
tool is shortly introduced and characterized along a criteria catalog
for CASE and MetaCASE tools.
Towards Generating DomainSpecific Model Editors with Complex Editing Commands
In Proc. International Workshop Eclipse Technology eXchange
(eTX)
Satellite Event of European Conf. on ObjectOriented Programming
(ECOOP), 2006.
Abstract. Domain specific modeling
languages are of increasing importance for the development of software
and other systems. Meta tools are needed to support rapid development
of domainspecific solutions. Usually, domainspecific modeling
languages are defined by providing a meta model using the MOF/EMF
approach. The language definition can be used to generate a
corresponding editor using meta tools such as Eclipse GMF. The meta
model defines all symbols and relations of the domainspecific model
which can be used to provide an editor with basic editing commands. In
addition, further language properties can be formulated by OCL
constraints which form the input to a syntax checker. If the modeling
language has not only simple syntax structures, syntaxdirected editing
would increase the convenience. Up to now, meta CASE tools being based
on EMF do not provide support for the definition of complex editing
commands. A natural way to define editing commands is the formulation
by transformation rules, specifying the pre and postconditions of
each command. The background for this approach is the grammarbased
definition of visual modeling languages. While the transformation rules
for simple commands can be generated automatically, complex commands
are defined by the language designer. The formal basis for this kind of
editor definition is given by graph transformation. A meta modelbased
editor specification extended by such rules shall be used to generate
Eclipse plugins for domainspecific editing with complex editing
commands.
 Claudia Ermel, Hartmut Ehrig and Gabriele Taentzer:
In Günter Hommel and Huanye Sheng (eds.), Proc. 7th Workshop on
Embedded Systems – Modeling, Technology, and Applications, Technische
Universität Berlin, pages 11–20. Springer Verlag, 2006.
Abstract. Behavior specification
techniques like Petri nets provide a visual description of software and
embedded systems as basis for behavior validation by simulation. Graph
transformation systems can be used as a unifying formal approach to
define various visual behavior modeling languages including different
kinds of Petri nets, activity diagrams, Statecharts etc., and to
provide models with an operational semantics defining simulations of
visual models based on graph transformation rules. Moreover, simulation
of visual models can be extended by animation which allows to visualize
the states of a model simulation run in a domainspecific layout which
is closer to the problem domain than the layout of the abstract
diagrammatic notation of the specification technique. This kind of
model transformation is defined also within the framework of graph
transformation, which allows to show interesting properties like
semantical correctness of the animation with respect to simulation. In
this paper we give an overview of simulation and animation of visual
models based on graph transformation and discuss corresponding
correctness issues.
 Dániel Varró, Szilvia VarróGyapay, Hartmut Ehrig, Ulrike
Prange and Gabriele
Taentzer:
Termination Analysis of Model Transformations by Petri
Nets
In Proc. Third International Conference on Graph Transformation
(ICGT'06), volume 4178 of LNCS, pages 260–274, Natal, Brazil, September
2006. Springer.
Abstract. Despite the increasing
relevance of model transformation techniques in modeldriven software
development, research is mainly conducted to the specification and the
automation of such transformations. However, since the transformations
themselves may also contain conceptual flaws, it is essential to
formally analyze them prior to executing them on user models. In the
current paper, we focus on a central validation problem of trusted
model transformations, namely, termination and propose a Petri net
based analysis method that provides a sufficient criterion for the
termination problem of model transformations captured by graph
transformation systems.
 Jessica Winkelmann, Gabriele
Taentzer, Karsten Ehrig and Jochen Malte Küster:
Translation of Restricted OCL Constraints into Graph
Constraints for Generating Meta Model Instances by Graph
Grammars
In Proc. International Workshop on Graph Transformation and Visual
Modeling Techniques (GTVMT'06), ENTCS, Vienna, Austria, April 2006.
Elsevier Science
Abstract. The meta modeling approach
to syntax definition of visual modeling techniques has gained wide
acceptance, especially by using it for the definition of UML. Based on
class structures and wellformedness rules, which could be formalized
by OCL, the abstract syntax of visual modeling techniques is defined in
a declarative way. Since metamodeling is nonconstructive, it does not
provide a systematic way available to generate all possible meta model
instances. But for example, when developing model transformations, it
is desirable to have a large set of valid instances at hand to perform
largescale testing. In our approach, an instancegenerating graph
grammar is automatically created from a given meta model. This graph
grammar ensures correct typing and cardinality constraints. To satisfy
also the given OCL constraints, wellformedness checks have to be done
in addition. As a first step, a restricted form of OCL constraints can
be translated to graph constraints which are to be checked during the
instance generation process.
 Paolo Bottoni, Kathrin Hoffmann, Francesco ParisiPresicce and Gabriele Taentzer:
HighLevel Replacement Units and their Termination
Properties
Journal of Visual Languages and Computing, 2005
Abstract. Visual rewriting
techniques, in particular graph transformations, are increasingly used
to model transformations of systems specified through diagrammatic
sentences. Several rewriting models have been proposed, differing in
the expressivity of the types of rules and in the complexity of the
rewriting mechanism; yet, for many of them, basic results concerning
the formal properties of these models are still missing. In this paper,
we give a contribution towards solving the termination problem for
rewriting systems with external control mechanisms. In particular, we
obtain results of more general validity by extending the concept of
transformation unit to highlevel replacement systems, a generalization
of graph transformation systems. For highlevel replacement units, we
state and prove several abstract properties based on termination
criteria. Then, we instantiate the highlevel replacement systems by
attributed graph transformation systems and present concrete
termination criteria. We explore some types of rules and replacement
units for which the criterion can be established. These are used to
show the termination of some replacement units needed to express model
transformations formalizing refactoring.
 Juan de Lara and Gabriele
Taentzer:
Modelling and Analysis of Distributed Simulation Protocols with
Distributed Graph Transformation
In
Proc. of Application of Concurrency to System Design. IEEE Computer
Society Press, 2005.
Abstract. This paper presents our
approach to model distributed discrete event simulation systems in the
framework of distributed graph transformation. In particular, we use
distributed typed attributed graph transformation to describe a
conservative simulation protocol. We use local control flows for rule
execution in each process as the use of a global control would imply a
completely synchronized evolution of all processes. These are specified
by a
Statechart in
which transitions are labelled with rule executions. States are encoded
as process attributes, in such a way that rules are only applicable if
the process is in a particular state. For the analysis, we introduce
a
flattening
construction as a functor from distributed to normal graphs. Global
consistency conditions can be defined for normal graphs which specify
safety properties for the protocol. Once the flattening construction is
applied to each rule, the global conditions can then be translated into
preconditions for the protocol rules, which ensure that the protocol
fulfills the global constraints in any possible execution. Finally, the
paper also discusses tool support using the AToM3 environment.
Attributed Graph Transformation with Node Type Inheritance: Long Version. Technical Report 2005/03, TU Berlin, 2005
 Hartmut Ehrig, Karsten Ehrig, Juan de Lara, Gabriele
Taentzer, Dániel Varró and Szilvia VarróGyapay:
Termination criteria for model
transformation
Proc. Fundamental Approaches to Software Engineering (FASE), volume
2984 of LNCS, pages 214–228. Springer, 2005.
Abstract. Model
Transformation
has become central to most software engineering activities. It refers
to the process of modifying a (usually graphical) model for the purpose
of analysis (by its transformation to some other domain), optimization,
evolution, migration or even code generation. In this work, we
show termination
criteria for
model transformation based on graph
transformation. This framework offers visual and formal techniques
based on rules, in such a way that model transformations can be subject
to analysis. Previous results on graph transformation are extended by
proving the termination of a transformation if the rules applied meet
certain criteria. We show the suitability of the approach by an example
in which we translate a simplified version of Statecharts into Petri
nets for functional correctness analysis.
 Hartmut Ehrig, Karsten Ehrig, Ulrike Prange and Gabriele Taentzer:
Formal Integration of Inheritance with Typed Attributed Graph
Transformation for Efficient VL Definition and Model
Manipulation
Proc.
IEEE Symposium on Visual Languages and HumanCentric Computing
(VL/HCC'05), IEEE Computer Society, Dallas, Texas, USA, September
2005
Abstract. Several approaches exist to
define a visual language (VL). Among those the metamodeling approach
used to define the Unified Modeling Language (UML), and the graph
transformation approach are very popular. Especially the combination of
both, using metamodeling to define the syntax of a VL and graph
transformation for specifying model transformations has been considered
conceptually and explored in a number of applications. A formal
integration of both approaches has just been started by integrating
classical algebraic graph grammars with a node type inheritance
concept. In this paper, the integration of inheritance is extending to
attributed graph transformation. More precisely, we define attributed
type graphs with inheritance leading to a formal integration of
inheritance with typed attributed graph transformation.
 Tom Mens, Gabriele Taentzer and Olga Runge:
Detecting Structural Refactoring Conflicts Using Critical Pair
Analysis
Electr. Notes Theor. Comput. Sci. 127(3): 113128 (2005).
Abstract. Refactorings are program
transformations that improve the software structure while preserving
the external behaviour. In spite of this very useful property,
refactorings can still give rise to structural conflicts when parallel
evolutions to the same software are made by different developers. This
paper explores this problem of structural evolution conflicts in a
formal way by using graph transformation and critical pair analysis.
Based on experiments carried out in the graph transformation tool AGG,
we show how this formalism can be exploited to detect and resolve
refactoring conflicts.

Hartmut Ehrig, Karsten Ehrig, Ulrike Prange and Gabriele Taentzer:
Fundamental Theory for Typed Attributed Graphs and Graph Transformation based on Adhesive HLR Categories
Fundamenta Informaticae, XX:1–31, 2005.
 Karsten Ehrig, Claudia Ermel, Stefan Hänsgen and Gabriele Taentzer:
Generation of visual editors as eclipse
plugins
In Proc. 20th IEEE/ACM International Conference on Automated Software
Engineering, IEEE Computer Society, Long Beach, California, USA,
2005.
Abstract. Visual Languages (VLs) play
an important role in software system development. Especially when
looking at welldefined domains, a broad variety of domain specific
visual languages are used for the development of new applications.
These languages are typically developed specifically for a certain
domain in a way that domain concepts occur as primitives in the
language alphabet. Visual modeling environments are needed to support
rapid development of domainspecific solutions. In this contribution we
present a general approach for defining visual languages and for
generating languagespecific tool environments. The visual language
definition is again given in a visual manner and precise enough to
completely generate the visual environment. The underlying technology
is Eclipse with its plugin capabilities on the one hand, and formal
graph transformation techniques on the other hand. More precisely, we
present an Eclipse plugin generating Java code for visual modeling
plugins which can be directly executed in the Eclipse
RuntimeWorkbench.
 Reiko Heckel and Gabriele Taentzer:
The Column on Visual Modelling Techniques
News on the SegraVis Research Training Network
Abstract. In this third Column on
Visual Modeling Techniques we present a first comparison of tools
developed by partners and grant holders of the Research Training
Network SegraVis on Syntactic and Semantic Integration of Visual
Modeling Techniques.
 Karsten Ehrig, Claudia Ermel and Gabriele Taentzer:
Erstellung eines grafischen EditorPlugIns mit Eclipse EMF und
GEF
OBJEKTspektrum, 2:31–34, 2005
Abstract. In dem Artikel wird die
Generierung eines einfachen baumbasierten Eclipse EditorPlugIns
anhand eines Editors für Petrinetze mit dem Eclipse Modeling Framework
(EMF) beschrieben. Aufbauend auf den generierten Modellcode wird die
Implementierung eines zweiten komplexeren grafischen EditorPlugIns
mit dem Graphical Editor Framework (GEF) erläutert.
 Claudia Ermel, Gabriele Taentzer and Roswitha Bardohl:
Simulating Algebraic HighLevel Nets by Parallel Attributed
Graph Transformation
In Kreowski et al.
Abstract. The "classical" approach to
represent Petri nets by graph transformation systems is to translate
each transition of a specific Petri net to a graph rule (behavior
rule). This translation depends on a concrete model and may yield large
graph transformation systems as the number of rules depends directly on
the number of transitions in the net. Hence, the aim of this paper is
to define the behavior of Algebraic HighLevel (AHL) nets, a highlevel
Petri net variant, by a parallel, typed, attributed graph
transformation system. Such a general parallel transformation system
for AHL nets replaces the translation of transitions of specific AHL
nets. After reviewing the formal definitions of AHL nets and parallel
attributed graph transformation, we formalize the classical translation
from AHL nets to graph transformation systems and prove the correctness
of the translation. The translation approach then is contrasted to a
definition for AHL net behavior based on parallel graph transformation.
We show that the resulting amalgamated rules correspond to the behavior
rules from the classical translation approach.
 Claudia Ermel, Gabriele Taentzer and Roswitha Bardohl:
Simulating Algebraic HighLevel Nets by Parallel Attributed
Graph Transformation: Long Version
Technical Report 200421, Technische Universität Berlin, 2005
Abstract. The "classical" approach to
represent Petri nets by graph transformation systems is to translate
each transition of a specific Petri net to a graph rule (behavior
rule). This translation depends on a concrete model and may yield large
graph transformation systems as the number of rules depends directly on
the number of transitions in the net. Hence, the aim of this paper is
to define the behavior of Algebraic HighLevel (AHL) nets, a highlevel
Petri net variant, by a parallel, typed, attributed graph
transformation system. Such a general parallel transformation system
for AHL nets replaces the translation of transitions of specific AHL
nets. After reviewing the formal definitions of AHL nets and parallel
attributed graph transformation, we formalize the classical translation
from AHL nets to graph transformation systems and prove the correctness
of the translation. The translation approach then is contrasted to a
definition for AHL net behavior based on parallel graph transformation.
We show that the resulting amalgamated rules correspond to the behavior
rules from the classical translation approach.
 A. Fish, J. Howse, Gabriele Taentzer and Jessica Winkelmann:
Two visualizations of OCL: a comparison
Technical Report VMG.05.1, University of Brighton, 2005
Abstract. We compare two
visualizations of OCL, VisualOCL and Constraint Diagrams, and establish
some of their benefits and weaknesses. These two notations were
designed to fit in to the diagrammatic modelling paradigm. We introduce
a simple case study, with constraints written in both natural language
and OCL, and visualize these constraints using VisualOCL and Constraint
Diagrams. Using a set of criteria which is based on cognitive,
syntactic and semantic questions, we compare the notations, with
reference to the sample constraints.
 Gabor Karsai and Gabriele Taentzer (eds.):
Proc. International Workshop on Graph and Model
Transformation (GraMoT'05)
ENTCS, Tallinn, Estonia, September 2005. Elsevier Science.
 HansJörg Kreowski, Ugo Montanari, Fernando Orejas, Grzegorz Rozenberg and Gabriele Taentzer (eds.):
Formal Methods in Software and Systems Modeling: Essays Dedicated to Hartmut Ehrig on the Occasion of His 60th Birthday, volume 3393 of LNCS. Springer, 2005.
 Arend Rensink and Gabriele Taentzer:
Ensuring structural constraints in graphbased models with type
inheritance
In Proc. Fundamental Approaches to Software Engineering (FASE), volume
3442 of LNCS, pages 64–79. Springer, 2005.
Abstract. Graphs are a common means
to represent structures in models and metamodels of software systems.
A classification of entities and their relations in class structures or
type graphs, has proved to be a very valuable concept in the context of
graphbased models being e.g. metamodels or graph transformation
systems. The constraints that can be imposed by pure typing are,
however, relatively weak. In the context of metamodelling it is common
practice to enrich type information with structural properties (such as
local invariants or multiplicity conditions) or inheritance. In this
paper, we show how to formulate structural properties using graph
constraints in type graphs with inheritance, and we show how to
translate constrained type graphs with inheritance to equivalent
constrained simple type graphs. From existing theory it then follows
that graph constraints can be translated into preconditions for
productions of a typed graph transformation system which ensures those
graph constraints. This result can be regarded as a further important
step of integrating metamodelling with graph transformation
concepts.
 Gabriele Taentzer, Karsten Ehrig, Esther Guerra, Juan de Lara, Laszlo Lengyel, Tihamer Levendovsky, Ulrike Prange, Dániel Varró and Szilvia VarróGyapay:
Model Transformation by Graph Transformation: A Comparative
Study
In Proc. Workshop Model Transformation in Practice, Montego Bay,
Jamaica, October 2005
Abstract. Graph transformation has
been widely used for expressing model transformations. Especially
transformations of visual models can be naturally formulated by graph
transformations, since graphs are well suited to describe the
underlying structures of models. Based on a common sample model
transformation, four different model transformation approaches are
presented which all perform graph transformations. At first, a basic
solution is presented and crucial points of model transformations are
indicated. Subsequent solutions focus mainly on the indicated problems.
Finally, a first comparison of the chosen approaches to model
transformation is presented where the main ingredients of each approach
are summarized.
A First Comparison of SegraVis Tools
EASST Newsletter, 10:12–23, 2005.
Abstract. In the wide area of visual
modelling techniques a large number of CASE and MetaCASE tools have
been developed to define and work with visual modelling techniques. In
this survey, we concentrate on those tools for visual modelling
techniques and languages which have been developed within the SegraVis
project. The main purpose of this first comparison is to get an
overview on the functionalities of such kind of tools and to better
understand each tool’s purpose and features.
Integrating Meta Modelling with Graph Transformation for
Efficient Visual Language Definition and Model
Manipulation
In M. Wermelinger and T. MargariaSteffens (eds.), Proc. Fundamental
Aspects of Software Engineering 2004, volume 2984. Springer LNCS,
2004.
 Paolo Bottoni, Manuel Koch, Francesco ParisiPresicce and Gabriele Taentzer:
Termination of HighLevel Replacement Units with Application to
Model Transformation
In Mark Minas (ed.), Proc. Workshop on Visual Languages and Formal
Methods, 2004.
Specifying Integrated Refactoring with Distributed Graph
Transformation
In J. Pfaltz, M. Nagl, and B. Boehlen (eds.), Application of Graph
Transformations with Industrial Relevance (AGTIVE'03), volume 3062.
Springer LNCS, 2004.
 Paolo Bottoni, Francesco ParisiPresicce and Gabriele Taentzer:
Specifying Coherent Refactoring of Software Artefacts with
Distributed Graph Transformations
In P. v. Bommel (ed.), Transformation of Knowledge, Information, and
Data: Theory and Applications. Idea Group Publishing, 2004.
Automated Model Transformation and its Validation using
AToM3 and AGG
In Alan Blackwell, Kim Marriott and Atsushi Shimojima (eds.),
Diagrammatic Representation and Inference. Springer, LNAI 2980,
2004.
 Juan de Lara, Claudia Ermel, Gabriele Taentzer and Karsten Ehrig:
Parallel Graph Transformation for Model Simulation applied to
Timed Transition Petri Nets
In Proc. Graph Transformation and Visual Modelling Techniques (GTVMT)
2004, 2004.
Fundamental Theory for Typed Attributed Graph
Transformation
In Francesco ParisiPresicce, Paolo Bottoni and Gregor Engels
(eds.)
Proc. 2nd Int. Conference on Graph Transformation (ICGT'04), LNCS 3256,
pages 161177, Rome, Italy, October 2004. Springer.
 Karsten Ehrig, Claudia Ermel, Stefan Hänsgen and Gabriele Taentzer:
Towards Graph Transformation Based Generation of Visual Editors
Using Eclipse
In Mark Minas (ed.), Visual Languages and Formal Methods, Electr. Notes
Theor. Comput. Sci. 127(4): 127143 (2005).
Abstract. This work discusses the
stateoftheart of visual editor generation based on graph
transformation concepts on one hand, and using the Eclipse technology
which includes the Graphical Editor Framework (GEF), on the other hand.
Due to existing shortcomings in both approaches, we present a combined
approach for a tool environment that allows to generate a GEFbased
editor from a formal, graphtransformation based visual language
specification.
 Tom Mens, Andy Schürr and Gabriele Taentzer:
Workshop on GraphBased Tools
In Francesco ParisiPresicce, Paolo Bottoni, and Gregor Engels
(eds.)
Proc. 2nd Int. Conference on Graph Transformation (ICGT'04), LNCS 3256,
pages 144160, Rome, Italy, October 2004. Springer.
 Tom Mens, Gabriele Taentzer and Olga Runge:
Detecting Structural Refactoring Conflicts unsing Critical Pair
Analysis
In Reiko Heckel and Tom Mens (eds.)
Proc. Workshop on Software Evolution through Transformations:
Modelbased vs. Implementationlevel Solutions (SETra'04), Satellite
Event of ICGT'04), Rome, Italy, October 2004. ENTCS.
 A. Qemali and Gabriele Taentzer:
Towards Validation of Session Management in Web Applications
based on Graph Transformation
In J. Pfaltz, M. Nagl, and B. Boehlen (eds.)
Application of Graph Transformations with Industrial Relevance
(AGTIVE'03), volume 3062. Springer LNCS, 2004.
AGG: A Graph Transformation Environment for Modeling and
Validation of Software
In J. Pfaltz, M. Nagl, and B. Boehlen (eds.)
Application of Graph Transformations with Industrial Relevance
(AGTIVE'03), volume 3062. Springer LNCS, 2004. IOGRAPHY 2004 >
strial Relevance (AGTIVE'03), volume 3062. Springer LNCS, 2004.
IOGRAPHY 2004
Node Type Inheritance Concepts for Typed Graph
Transformation
Technical Report 200319, Technical University Berlin, Dept. of
Computer Science, November 2003
ISSN 14369915
In T. Margaria (ed.), Proc. Tool Exihibition at "Formal Methods 2003", Pisa, Italy, September 2003.
 C. Kiesner, Gabriele Taentzer and Jessica Winkelmann:
VisualOCL: A Visual Notation of the Object Constraint
Language
Technical report at the Computer Science Department of the Technical
University of Berlin, No. 2002/23
Abstract. The Object Constraint
Language (OCL) is a formal language which was developed as extension of
the Unified Modeling Language (UML). OCL is used to specify invariants,
pre and post conditions of operations, methods or state changes. In
contrast to UML, OCL is a pure expression language; therefore, the
notation of an OCL expression has a completely different notation of
model elements as the UML. This document introduces a visualization of
OCL based on the OCL meta model which will be part of the UML version
2.0. So the notation of Visual OCL(VOCL) is meant as an alternative
solution to the textual OCL. Chapter 2 describes the visualisation of
OCL considering a variety of examples. Chapter 3 includes the
visualized OCL standard library. For each operation in OCL this chapter
describes the visualized notation. The appendix represents instances of
the meta model describing some VOCL constraints used in Chapter 2. This
work is done in the context of a student's project on visual languages
which took place at Technische Universität Berlin under the guidance of
Gabriele
Taentzer in summer 2002. This document is based on conceptual work
by Bottoni, Koch, ParisiPresicce und Taentzer.
 Tom Mens, Andy Schürr and Gabriele
Taentzer (eds.):
GraphBased Tools (GraBaTs'02)
Volume 72 of Electronic Notes in Theoretical Computer Science
(ENTCS)
Abstract. Graphs are wellknown,
wellunderstood, and frequently used means to depict networks of
related items. They are successfully used as the underlying
mathematical concept in various application domains. In all these
domains tools are developed that store, retrieve, manipulate and
display graphs. It is the purpose of this workshop to summarize the
state of the art of graphbased tool development, bring together
developers of graphbased tools in different application fields and to
encourage new tool development cooperations.
 Paolo Bottoni, Francesco ParisiPresicce and Gabriele Taentzer:
Coordinated Distributed Diagram Transformation for Software
Evolution
Reiko Heckel, Tom Mens, Michel Wermelinger (eds.)
Proc. of the Workshop on 'Software Evolution Through Transformations'
(SET'02)
Volume 72 of Electronic Notes in Theoretical Computer Science
(ENTCS)
Abstract. We present an approach to
maintaining code and specification consistent in presence of
refactoring, where the specification consists of several diagrams from
different UML diagram families. Distributed graph transformations are
applied in a coordinated way over the different diagrams. Refactoring
itself is modelled as a graph transformation over a flowgraph
representing the code, while the UML diagrams are taken to represent
different views of the code.
 Reiko Heckel, Jochen Malte Küster and Gabriele Taentzer:
Confluence of Typed Attributed Graph Transformation
Systems
Andrea Corradini, Hartmut Ehrig, HansJörg Kreowski, Grzegorz Rozenberg
(eds.):
Graph Transformation, 1st Int. Conference, ICGT 2002, Barcelona, Spain,
October 2002, Springer LNCS 2505
Abstract. The issue of confluence is
of major importance for the successful application of attributed graph
transformation, such as automated translation of UML models into
semantic domains. Whereas termination is undecidable in general and
must be established by carefully designing the rules, local confluence
can be shown for term rewriting and graph rewriting using the concept
of critical pairs. In this paper, we discuss typed attributed graph
transformation using a new simplified notion of attribution. For this
kind of attributed graph transformation systems we establish a
definition of critical pairs and prove a critical pair lemma, stating
that local confluence follows from confluence of all critical
pairs.
 Jan Hendrik Hausmann, Reiko Heckel and Gabriele Taentzer:
Detection of Conflicting Functional Requirements in a Use
CaseDriven Approach
Proc. of the 24th Int. Conference on Software Engineering 2002,
Orlando, USA, IEEE Computer Society
Abstract. In objectoriented software
development, requirements of different stakeholders are often
manifested in use case models which complement the static domain model
by dynamic and functional requirements. In the course of development,
these requirements are analyzed and integrated to produce a consistent
overall requirements specification. Iterations of the model may be
triggered by conflicts between requirements of different parties.
However, due to the diversity, incompleteness, and informal nature, in
particular of functional and dynamic requirements, such conflicts are
difficult to find. Formal approaches to requirements engineering, often
based on logic, attack these problems, but require highly specialized
experts to write and reason about such specifications.
In this paper, we propose a formal interpretation of use case models
consisting of UML use case, activity, and collaboration diagrams. The
formalization, which is based on concepts from the theory of graph
transformation, allows to make precise the notions of conflict and
dependency between functional requirements expressed by different use
cases. Then, use case models can be statically analyzed, and conflicts
or dependencies detected by the analysis can be communicated to the
modeler by annotating the model. An implementation of the static
analysis within a graph transformation tool is presented.
A Visual Modeling Framework for Distributed Object
Computing
Formal methods for open objectbased distributed systems V
B. Jacobs and A. Rensink (eds.), Kluwer Academic Publishers, 2002
Abstract. Distributed object
computing is a computing paradigm that allows objects to be distributed
over a heterogeneous network. Infrastructures help to develop
distributed object applications by offering necessary services for
distributed computing. Having a comprehensive infrastructure to hand,
the development of complex distributed object systems is feasible in
principle. Flexibly evolving architectures as well as highly dynamic
distributed object structures are key requirements for nowadays
distributed solutions. They can hardly be well designed on this level
of programming, due to their complexity. A visual modeling framework is
presented which offers a more abstract and intuitive approach to the
relevant aspects of a distributed object system. In this framework,
network and object structures as well as their evolution are visualized
in a diagrammatic style, e.g. in UML notation. Semantically, this
approach relies on graphs and their transformation, i.e. it has a
precise background useful for further reasoning.
 Reiko Heckel, Jochen Malte Küster and Gabriele Taentzer,
Towards Automatic Translation of UML Models into Semantic
Domains
Applied Graph Transformation (AGT`02), satellite event of ETAPS'02,
Grenoble, 2002
HansJörg Kreowski and P. Knirsch (eds.)
Abstract. The use of UML for software
specification leads usually to lots of diagrams showing different
aspects and components of the software system in several views. In
order to support a vieworiented approach to system modeling,
consistency in views and in between views has to be manageable. It is a
reasonable approach to consistency management when first choosing a
suitable semantic domain, provide a partial mapping into this domain,
and specify as well as verify consistency constraints formulated in
that domain. Annotated meta model rules can be used to translate
elements of UML models into the semantic domain chosen. In this
contribution, we consider triple graph grammars and attributed graph
transformation approaches for the precise definition of meta model
rules and outline the tool support for automatic translation.
 Paolo Bottoni, Manuel Koch, Francesco ParisiPresicce, Gabriele Taentzer:
Working on OCL with Graph Transformation
Applied Graph Transformation (AGT`02), satellite event of ETAPS'02,
Grenoble, 2002
HansJörg Kreowski and P. Knirsch (eds.)
Abstract. The Object Constraint
Language (OCL) provides an important complement to visual formalisms
used in the definition of UML languages. Yet, its usage is limited by
two major drawbacks. The first is the limited availability of tools for
the automatic verification of constraints against model diagrams. The
second is the difficulty of amalgamating a textual formalism such as
OCL with the visual languages used in the rest of UML. We attack these
problems with methods deriving from a graphtransformation based
approach. We propose a visualisation of OCL, based on a recently
proposed metamodel for it, which provides a declarative way to
represent OCL constraints, and then we discuss how an operational
semantics for OCL can be based on transformation units which guide the
application of graphtransformation rules.
 Paolo Bottoni, Manuel Koch, Francesco ParisiPresicce, Gabriele Taentzer:
A Visualization of OCL using Collaborations
UML 2001, Gogolla, M. and Kobryn, C. (eds.), Toronto, Canada, Springer
LNCS 2185
Abstract. We propose a visualization
of OCL within the context of the UML meta model, so that OCL
expressions are represented by extending collaboration diagrams. We
exploit the OCL meta model introduced in [RG99] and further elaborated
on in [Bod00] and base the description of properties of objects on
collaborations, while classifier and association roles are used to
describe navigation paths. Operations computing properties are
described by interactions consisting of messages between classifier
roles. The introduction of new graphical core elements is kept to a
minimum. New notation mainly concerns the predefined operations in OCL
and provides more convenient visual forms for the notation by
interactions here. The proposed visualization is described in detail
and is illustrated with examples taken from an industrial project under
development.
Visual Modeling of Distributed Object Systems by Graph
Transformation,
in M. Bauderon and Andrea Corradini (eds.)
Proc. GETGRATS Closing Workshop, Electronic Notes in Theoretical
Computer Science (ENTCS), Vol. 55, 2001
Abstract. A visual modeling technique
for distributed object systems based on graph transformation is
presented. It includes the graphical description of the network and its
dynamic reconfiguration as well as the component interfaces and local
object systems and their behavior. Typical issues in distributed
systems like remote object interaction, object migration and
replication, communication and synchronization are expressible in this
technique. The notation is close to UML. It extends the UML notation
where needed. Using graph transformation as underlying formal
framework, distributed behavior is designed in a way that consistency
of the network, as well as of all object and data structures involved,
is ensured.
Towards Common Exchange Formats for Graphs and Graph
Transformation Systems
Proc. Uniform Approaches to Graphical Process Specification Techniques
UNIGRA'01 (Julia Padberg, ed.)
in Electronic Notes on Theoretical Computer Science 47, 2001
Abstract. The development of common
exchange formats for graphs and graph transformation systems is an
ongoing initiative within the EU Working Group APPLIGRAPH (Applications
of Graph Transformation). The author is reporting on the current state
of this format discussion. The formats are based on the extensible
markup language XML developed to interchange documents of arbitrary
types. Graphs are basic structures in various areas of computer
science. A common format for graphs supports the interaction of
software developers building tools wrt. graph layout, graph algorithms,
graph transformation, reengineering, etc. Moreover, within the graph
transformation community tool builders can even gain from a common
exchange format for graph transformation systems.
 Gabriele Taentzer and Hartmut Ehrig:
Semantics of Distributed System Specifications based on Graph
Transformation
presented at GIJahrestagung 2000, Workshop "Rigorose Entwicklung
softwareintensiver Systeme", Berlin, 2000
Abstract. Distributed algorithms and
dynamic distributed data structures are basic aspects of distributed
systems which usually are modelled separately by different
specification techniques. In the running example of the mutual access
to file systems, typical problems are shown which are not handled by
separate modelling. This paper discusses how these problems can be
solved by integrated specification of distributed algorithms and
dynamic data structures by graph transformation. From the component
point of view it is even more adequate to use distributed graph
transformation for the semantics of distributed system
specification.
 Paolo Bottoni, Manuel Koch, Francesco ParisiPresicce, Gabriele Taentzer:
Consistency Checking and Visualization of OCL
Constraints
UML 2000, York, Springer LNCS 1939, 2000
Abstract. Part of the success of the
Unified Modeling Language (UML) as a specification language is due to
its diagrammatic nature. Its meaning is expressed by its meta model, a
combination of class diagrams and constraints written in the Object
Constraint Language (OCL), a textual language of expressions. Recent
efforts have tried to give a formal semantics to OCL in a classical
way. In this paper, we propose a graphbased semantics for OCL and a
systematic translation of OCL constraints into expressions over graph
rules. Besides providing a semantical formalization of OCL, this
translation can be employed to check the consistency of UML model
instances wrt. the constraints, using a general purpose graph
transformation machine like AGG or PROGRES. The translation of OCL
constraints into graph rules suggests a way to express the constraints
in a more intuitive visual form.
 Paolo Bottoni, Andy Schürr and Gabriele Taentzer:
Efficient Parsing of Visual Languages based on Critical Pair
Analysis and Contextual Layered Graph Transformation
VL 2000, Seattle, IEEE Computer Society, 2000
Abstract. This paper proposes an
extension of layered graph grammars (LGGs), which have been introduced
for the definition of visual languages (VLs). Offering new constructs
like negative application conditions (NACs) it allows one to produce
more concise VL definitions. A new layering condition and critical pair
analysis are the prerequisites for a new parsing algorithm which avoids
the exponential behaviour of LGGs in many cases.
 Gabriele Taentzer and Hartmut Ehrig
A Proposal for Consistent Integration of Visual Computing with
Visual Development of Software Components
Proc. of Satellite Workshops of 27th Int. Colloquium on Automata,
Languages, and Programming, Carleton Scientifc, 2000
Abstract. On one hand visual
techniques are important for specification, modelling and programming,
in short visual computing, and on the other hand they can be used to
support component technology, evolution and the software development
process, in short visual development of software components. The paper
points out the central role of graphs and graph transformation for
visual computing and visual development of software components.
Moreover, it discusses the need for consistent integration of both
areas and to propose graph transformation as a suitable technique for
this purpose. The general idea of this position paper is not to present
new technical results but to propose new lines of research how to
combine and extend current projects and proposals in the areas of
visual computing and visual development of software respectively.
 Stefan Gruner, Murat Kurt and Gabriele Taentzer
A Visual Modeling Technique for Controlling Graph
Transformation
Proc. of Satellite Workshops of 27th Int. Colloquium on Automata,
Languages, and Programming, Carleton Scientifc, 2000
 Michael Goedicke, Bettina Enders, Torsten Meyer and Gabriele Taentzer:
ViewPointOriented Software Development: Tool Support for
Integrating Multiple Perspectives by Distributed Graph
Transformation,
Proc. 6th Int. Conf. on Tools and Algorithms for the Construction and
Analysis of Systems, Berlin, Germany, LNCS 1785, Springer, 2000
 Martin GroßeRhode, Francesco ParisiPresicce, Marta Simeoni and Gabriele Taentzer:
Modeling Distributed Systems by Modular Graph Transformation
based on Refinement of Rule Expressions
Proc. of Applications of Graph Transformation with Industrial
Relevance, Kerkrade, The Netherlands, LNCS, Springer, 2000
AGG: A Tool Enviroment for Algebraic Graph
Transformation
Proc. of Applications of Graph Transformation with Industrial
Relevance, Kerkrade, The Netherlands, LNCS, Springer, 2000.
Abstract. AGG is a general tool
environment for algebraic graph transformation which follows the
interpretative approach. Its special power comes from a very flexible
attribution concept. AGG graphs are allowed to be attributed by any
kind of Java objects. Graph transformations can be equipped with
arbitrary computations on these Java objects described by a Java
expression. The AGG environment consists of a graphical user interface
comprising several visual editors, and an interpreter which is also
usable without the graphical interface.
 Ingrid Fischer, Manuel Koch and Gabriele Taentzer:
Local
Views on Distributed Systems and their Communication
Proc. 6th Int. Workshop on Theory and Application of Graph
Transformation (TAGT'98), Nov. 1998, Paderborn, Germany, LNCS 1764,
Springer, 2000.
Abstract. Distributed graph
transformation has been used to specify static as well as dynamic
aspects of distributed systems. To support distributed designs by
different developers, local views are introduced. A local view on a
distributed system consists of one local system, its import and export
interfaces, and connected remote interfaces. The behavior of a local
system is specified by a set of graph rules that are applicable only to
the local view of the local system. Local systems communicate either
synchronously or asynchronously via their import and export interfaces.
Asynchronous communication is modeled by sequential application of
graph rules, synchronous communication by the amalgamation of graph
rules. We compose a distributed system grammar from the rule sets for
local systems. The operational semantics of the distributed system is
given by distributed transformation sequences.
Distributed Graphs and Graph Transformation
Applied Categorical Structures, Special Issue on Graph Transformation,
Vol. 7, No. 4, Dec. 1999
Abstract. The new approach of
distributed graphs and graph transformation as developed in this
article allows to use structured graph transformation on two
abstraction levels, the network and the local level. The network level
contains the description of the topological structures of a system. The
local level covers the description of states and their transitions in
local systems. Local state transitions may depend on others using
suitable synchronization mechanisms. The main distribution concepts of
categorical graph grammars presented by Schneider are combined with the
algebraic approach to distributed graph transformation introduced by
Ehrig et.al. Modeling of distributed systems by this new kind of
distributed graph transformation offers a clear and elegant description
of dynamic networks, distributed actions as well as communication and
synchronization using a graphical notation. Moreover, distributed graph
transformation offers the possibility to describe splitting and joining
of local graphs as well as parallel transformations in local systems.
The formalization of distributed graph transformation is done by means
of category theory. A distributed graph is formalized by a diagram in
the category GRAPH of graphs and total graph morphisms. A distributed
transformation step is characterized by a doublepushout in the
category DISTR(GRAPH) of distributed graphs and distributed graph
morphisms. A pushout over distributed graph morphisms cannot always be
constructed componentwise in each local part. But especially the
componentwise construction of a distributed transformation reflects
distributed computations best. Thus, we present the necessary
conditions for componentwise construction of pushouts in DISTR(GRAPH)
and show that they are also sufficient. These conditions are summarized
in the distributed gluing condition. Moreover, these conditions are
needed for componentwise construction of pushout complements which are
used to characterize the first step of a distributed graph
transformation.
 Michael Goedicke, Torsten Meyer and Gabriele Taentzer:
Dynamic Change Management by Distributed Graph Transformation:
Towards Configurable Distributed Systems
Proc. 6th Int. Workshop on Theory and Application of Graph
Transformation (TAGT'98), Oct. 1998, Paderborn, Germany, LNCS 1764,
Springer, 2000.
 Gabriele Taentzer, Michael Goedicke and Torsten Meyer:
Dynamic Accomodation of Change: Automated Architecture
Configuration of Distributed Systems
Automated Software Engineering'99, Cocoa Beach, Florida, USA, 1999,
IEEE Computer Society
 Roswitha Bardohl, Gabriele Taentzer, Mark Minas and Andy Schürr:
Application of Graph Transformation to Visual
Languages
Handbook on Graph Grammars and Computing by Graph Transformation,
Volume 2: Applications, Languages and Tools, World Scientific,
1999
Abstract. Graph transformation seems
to be especially appealing to define the syntax of visual languages
since visual languages have multidimensional representations which
have to be coded into onedimensional strings otherwise. Furthermore,
graph transformation as visual formalism is used as a basis for a
certain kind of rulebased visual languages. This chapter considers
both aspects of graph transformation applied to visual languages.
Graphs may be used to define visual sentences consisting of a set of
visual symbols such as graphic primitives, icons or pictures, and a set
of relations in between. Graph grammars are thus a natural means for
defining a visual language in terms of its graph language. Using graph
grammars for visual language definition, types of visual languages are
tightly coupled with types of graph languages. Expressive power of a
visual language type has to be considered carefully against efficiency
of tools, e.g., when parsing visual languages. Contextfree as well as
different kinds of contextsensitive languages are considered in this
chapter. Based on these concepts, two VL environment generating tools
and languagesDiaGen and GenGEdare presented that comprise
generators for visual editors and parsers based on syntax definition by
graph transformation. Graph transformation languages form a kind of
very highlevel visual programming languages, where the underlying data
models are graphs allowing to represent any kind of complex, structured
information at a convenient level of abstraction. The programming
paradigm to manipulate such graph data models is graph transformation
performed by applying graph rules. General purpose languages PROGRES
and AGG as well as special purpose languages DiaGen and GenGEd are
discussed and compared with each other.
 Gabriele Taentzer, Claudia Ermel and M. Rudolf:
The AGG Approach: Language and Tool
Environment
Handbook of Graph Grammars and Computing by Graph Transformation,
Volume 2: Applications, Languages and Tools, World Scientific,
1999.
Abstract. The Attributed Graph
Grammar system AGG provides a visual programming environment which is
based on graph transformation and Java. The idea is to program the
topmost object structures of an application as well as its dynamics
visually. For this purpose, these structures are designed as graphs
which may be attributed by Java objects and further arbitrary data. The
application's behavior is described by graph rules using an
ifthenprogramming style. Application of a graph rule changes the
structure graph. Control flow is not programmed at all, but implicitly
handled by the dependency of rule applications. Basic data types as
well as object classes already available in class libraries may be used
to program the application "in the small". Moreover, new classes may be
included. This part of the application is done textually using the
modern objectoriented programming language Java. The visually and the
textually programmed application parts are combined by attributing the
structure graphs by attribute values. These may be data as well as
object references. The graph rules may be attributed by Java
expressions which are evaluated during rule applications. It's up to
the programmer's decision how much of the application is realized
visually and how much textually. Combining visual and textual
programming in this way, programming should become easier because of
visual concepts. On the other side, the wheel is not reinvented again,
since well elaborated programming concepts, tools and class libraries
mirroring the state of the art of programming can be used. The tool
environment provides graphical editors for graphs and rules as well as
a textual editor for Java expressions integrated into the visual
editors. Moreover, visual interpretation and debugging of AGG programs
is supported.
 Gabriele Taentzer, Ingrid Fischer, Manuel Koch and V. Volle:
Distributed Graph Transformation with Application to Visual
Design of Distributed Systems
Handbook of Graph Grammars and Computing by Graph Transformation,
Volume 3: Parallelism,Concurrency and Distribution, World Scientific,
1999.
 Michael Goedicke, Torsten Meyer and Gabriele Taentzer:
ViewPointoriented Software Development by Distributed Graph
Transformation: Towards a Basis for Living with
Inconsistencies
in Proc. of Requirements Engineering'99, Limerick, Ireland, 1999.
Adding Visual Rules to ObjectOriented Modeling
Techniques
in Proc. of Technology of ObjectOriented Languages and Systems
(TOOLS'99), IEEE, Nancy, France, 1999.
 Hartmut Ehrig, Gregor Engels, Reiko Heckel and Gabriele Taentzer:
Classification and Comparison of Modularity Concepts for
Graph Transformation Systems
in Proc. 6th Int. Workshop on Theory and Application of Graph
Transformation (TAGT'98), Nov. 1998, Paderborn, Germany
 Ingrid Fischer, Manuel Koch and Gabriele Taentzer:
Visual Design of Distributed Systems by Graph
Transformation,
in Proc. of the Int. Workshop on CommunicationBased Systems, Oct.
1998, TU Berlin, Germany, Techn. Report 9815
How to Integrate Graph Transformation with an
ObjectOriented Language,
in Proc. 6. Int. Workshop on Theory and Application of Graph
Transformation (TAGT'98), Nov. 1998, Paderborn, Germany
 Roswitha Bardohl and Gabriele Taentzer:
Defining Visual Languages by Algebraic Specification
Techniques and Graph Grammars,
in Proc. IEEE Symposium on Theory of Visual Languages, 1997
Abstract. This contribution follows
the line of research to formally define a visual language by algebraic
concepts and techniques. In this paper, a graphic i.e. a sentence of a
visual language, is equipped with an underlying graph structure. This
is done in a way that each graph object of the graph structure is
represented by a graphic which may be a complex one. Graph structures
are regarded as nsorted algebras to equational specifications. The
symbols of the underlying alphabet are visually represented by graphics
and formulated by different sorts. The operations define how the
symbols are linked and the equation part formulates layout constraints.
Algebraic graph grammars are used to describe the visual language by
using the predefined symbols and links. Based on these theoretical
concepts we sketch how a visual language can be visually defined using
different graphical editors.
Parallel HighLevel Replacement Systems
in TCS, Vol. 186, 1997
Abstract. Highlevel replacement
systems are an axiomatic categorical framework based on doublepushouts
in order to unify replacement systems like grammars for different kinds
of graphs and relational structures or other types of structures like
algebraic specifications. Parallel highlevel replacement systems are
introduced to formalize parallel rewriting of these highlevel
structures. On one hand this concept generalizes and extends parallel
graph grammars presented so far in the algebraic approach by allowing
other structures than graphs, on the other hand the kinds of
replacement introduced for highlevel replacement systems are extended
by different types of parallel replacement which are compared to each
other in different parallel replacement theorems. An abstract version
of a windowbased graph editor and movement of objects in configuration
spaces are presented as examples of parallel highlevel replacement
systems.

Gabriele Taentzer and Manuel Koch:
Distributing Attributed Graph Transformation
In First TMR GETGRATS Workshop, Bordeaux, October 1997
 Hartmut Ehrig, Reiko Heckel, Gabriele Taentzer and Gregor Engels:
A Combined Reference Model and ViewBased Approach to System
Specification,
International Journal of Engineering and Knowledge Engineering, Vol.7
No.4 (1997), pp. 457477, World Scientific Publishing Company
Abstract. The idea of a combined
reference model and viewbased specification approach has been
proposed recently in the software engineering community. In this paper
we present a specification technique based on graph transformations
which supports such a development approach. The use of graphs and graph
transformations allows to satisfy the general requirements of an
intuitive understanding and the integration of static and dynamic
aspects on a welldefined and sound semantical base. On this
background, formal notions of view and view relation are developed and
the behaviour of views is described by a loose semantics. View
relations are shown to preserve the behaviour of views. Moreover, we
define a construction for the automatic integration of views which
assumes that the dependencies between different views are described by
a reference model. The views and the reference model are kept
consistent manually, which is the task of a model manager. In case of
more than two views more general scenarios are developed and discussed.
We are able to show that the automatic view integration is compatible
with the loose semantics, i.e., the behaviour of the system model is
exactly the integration of the behaviours of the views. concepts and
results are illustrated at the wellknown example of a banking
system.
 Gregor Engels, Reiko Heckel, Gabriele Taentzer and Hartmu Ehrig:
A ViewOriented Approach to System Modelling Using Graph
Transformations
in Proc. of ESEC/FSE'97, Zürich, LNCS 1301, Springer, 1997
Abstract. The idea of a combined
reference model and viewbased specification approach has been
proposed recently in the software engineering community. In this paper
we present a specification technique based on graph transformations
which supports such a development approach. The use of graphs and graph
transformations supports an intuitive understanding and an integration
of static and dynamic aspects on a welldefined semantical base. On
this background, formal notions of view and view relation are developed
and the behaviour of views is described by a loose semantics. We define
a construction for automatic view integration which assumes that the
dependencies between different views are described by a reference
model. The views and the reference model are kept consistent manually,
which is the task of a model manager. All concepts and results are
illustrated at the wellknown example of a banking system.
Modeling Dynamic Distributed Object Structures by Graph
Transformation
in online magazine Object Currents, vol.1, no. 12, 1996
Abstract. Objectoriented software
development methodologies are based on a number of graphical notations
describing the key aspects of a system. There is an increasing research
interest to incorporate distribution issues into development methods.
Allocation of objects and tasks, object replication and migration,
remote interactions, multiple threads of control as well as dynamic
network topologies are important issues in distributed object systems.
In this article, a graphical notation for dynamic distributed object
structures is presented which uses graph transformation as underlying
formal framework.
This new approach integrates networking aspects with object structures
and object interaction concerns. The description is performed on two
abstraction levels: the network and the local level. The network level
focuses on the topological structure of a system. The local level
contains snapshots showing local object structures which may evolve
independently or dependently of others using suitable interaction
mechanisms. Distributed operations for the description of dynamic
networks, communication and synchronization are modeled in a rulebased
manner by showing object structure parts before and after. Applying
several rules, i.e. performing distributed graph transformation,
results in a distributed scenario. The advantage of using rules is the
modeling of multiple threads of control on the level of events.
Using graph transformation as underlying formal framework, distributed
object structures may be modified on the network and on the local level
concurrently in such a way that consistency of the resulting
distributed object structure is ensured.
 Marc Andries, Gregor Engels, Annegret Habel, Berthold Hoffmann, HansJörg Kreowski, Sabine Kuske, Detlef Plump, Andy Schürr and Gabriele Taentzer:
Graph Transformation for Specification and
Programming
in Science of Computer Programming 34 (1999), 154
Abstract. The framework of graph
transformation combines the potentials and advantages of both, graphs
and rules, into a single computational paradigm. In this paper we
survey recent developments in applying graph transformation as a
rulebased framework for the specification and development of systems,
languages, and tools. After presenting the basic features of graph
transformation, we discuss a spectrum of applications including the
evaluation of functional expressions, the specification of an
interactive graphical tool, an example specification for abstract data
types, and the definition of a visual database query language. The case
studies indicate the need for a graph transformation language that
provides suitable structuring principles and is independent of a
particular graph transformation approach. To this end, we sketch the
basic features of the new graph and rulecentered language GRACE,
currently under development, that permits systematic and structured
specification and programming based on graph transformation.
 Hartmut Ehrig and Gabriele Taentzer:
Computing by Graph Transformation. A Survey and Annotated
Bibliography
Technical Report, TU Berlin, No. 9621
Introduction. The research area of graph
grammars or graph transformations is a discipline of computer science
which dates back to the early seventies. Methods, techniques, and
results from the area of graph transformations have already been
studied and applied in many fields of computer science such as formal
language theory, pattern recognition and generation, compiler
construction, software engineering, concurrent and distributed systems
modeling, database design and theory, logical and functorial programm,
AI etc. ( cont'd)
 Hartmut Ehrig and Gabriele Taentzer:
Computing by Graph Transformation. Final
Report
Technical Report, TU Berlin, No. 9617
Introduction. The research area of graph
grammars or graph transformations is a discipline of computer science
which dates back to the early seventies. Methods, techniques, and
results from the area of graph transformations have already been
studied and applied in many fields of computer science such as formal
language theory, pattern recognition and generation, compiler
construction, software engineering, concurrent and distributed systems
modeling, database design and theory, logical and functorial programm,
AI etc. (cont'd)
Parallel and Distributed Graph Transformation: Formal
Description and Application to CommunicationBased
Systems.
Ph.D.Thesis, TU Berlin, Shaker Verlag, Germany, 1996
Abstract. The overall aim of this
thesis is the development of new concepts for parallel and distributed
graph transformation to increase their applicability to
communicationbased systems. All concepts for parallel and distributed
graph transformation presented are formalized and compared with respect
to their expressive power. Based on parallel graph grammars introduced
by Ehrig and Kreowski the main concepts of existing approaches to
parallel graph replacement are integrated into a new approach and
generalized concerning flexible synchronization mechanisms for parallel
actions and restriction concepts for unbounded parallel execution of
actions. Distributed graph transformation as developed in this thesis
combines structured graph transformation on two abstraction levels, the
network and the local level, with the concept of synchronization by
interface graphs into a new approach. In this new approach the main
distribution concepts of categorical graph grammars presented by
Schneider are combined with the algebraic approach to distributed graph
transformation introduced by Ehrig et.al. Modeling of distributed
systems by this new kind of distributed graph transformation offers a
clear and elegant description of dynamic networks, distributed actions
as well as communication and synchronization based on graph
transformation. The formal description of parallel and distributed
graph transformation is based on the doublepushout approach to graph
transformation including all concepts presented above. Especially
distributed graph transformation can be very clearly described by
category theory. The parallel graph transformation types developed in
this thesis are compared with each other and with sequential graph
transformation concerning their expressive power. Moreover, distributed
graph transformation is shown to be closely related to parallel graph
transformation if parallel graph transformation is extended by adding
distribution structure compatible with the application structure of
parallel productions.
Hierarchically Distributed Graph
Transformation,
in Cuny, J., Hartmut Ehrig, Gregor Engels and Rozenberg, G. (eds.),
Graph Grammars and Their Applications to Computer Science, LNCS 1073,
Springer, Berlin, 1996
Abstract. Hierarchically distributed
graph transformation offers means to model different aspects of open
distributed systems very intuitively in a graphical way. The
distribution topology as well as local object structures are
represented graphically. Distributed actions such as local actions,
network activities, communication and synchronization can be described
homogeneously using the same method: graph transformation. This new
approach to graph transformation follows the lines of algebraic and
categorical graph grammars and fits into the framework of
doublepushout highlevel replacement systems.
Towards Synchronous and Asynchronous Graph
Transformations
in special issue of Fundamenta Informaticae, vol. 26, no.3,4,
1996
Abstract. Synchronous and
asynchronous graph transformations are discussed on the basis of
distributed graph transformations. All types of graph transformations
presented are formulated in the singlepushout approach to graph
transformations and compared with each other. Some criteria are given
to preserve or reestablish synchrony according to the definition
proposed in this paper.
 Annegret Habel, Reiko Heckel, Gabriele Taentzer:
Graph Grammars with Negative Application
Conditions
in special issue of Fundamenta Informaticae, vol. 26, no.3,4,
1996
Abstract. In each graphgrammar
approach it is defined how and under which conditions graph productions
can be applied to a given graph in order to obtain a derived graph. The
conditions under which productions can be applied are called
application conditions. Although the generative power of most of the
known general graphgrammar approaches is sufficient to generate any
recursively enumerable set of graphs, it is often convenient to have
specific application conditions for each production. Such application
conditions, on the one hand, include context conditions like the
existence or nonexistence of nodes, edges, or certain subgraphs in the
given graph as well as embedding restrictions concerning the morphisms
from the lefthand side of the production to the given graph. In this
paper, the concept of application conditions introduced by Ehrig and
Habel is restricted to contextual conditions, especially negative ones.
In addition to the general concept, we state local confluence and the
Parallelism Theorem for derivations with application conditions.
Finally we study contextfree graph grammars with application
conditions with respect to their generative power.
 Hartmut Ehrig and Gabriele Taentzer:
Computing by Graph Transformation II (COMPUGRAPH II). Third
Interim Report ESPRIT Basic Research Working Group No.
7183.
Technical Report No. 9523, TU Berlin, FB 13, 1995.
Introduction. This report gives an
overview over the ongoing activities of the ESPRIT Basic Research
Working Group "Computing by Graph Transformation" started on March 1st,
1989. Its second phase  COMPUGRAPH II  began on October 1st, 1992 and
lasts to March 31st, 1996. The main aim of the COMPUGRAPH project is to
demonstrate the potential of graph transformation as a uniform
framework for the development of modern software systems. The research
activities therefore cover the whole spectrum from theoretical
investigations to practical software engineering applications. This is
reflected in the following research areas according to which the work
in the COMPUGRAPH project has been organized: Foundations, Concurrent
computing, and Graph transformation for specification and programming
(cont'd)
 Mirko Conrad, Magdalena Gajewsky, Rainer HollBiniasz, Michael Rudolf, Jochen Demuth, Stephan Weber, Reiko Heckel, Jürgen Müller, Gabriele Taentzer, Annika Wagner:
Graphische Spezifikation ausgewählter Teile von AGG  einem
algebraischen Graphgrammatiksystem
Technical Report 957, TUBerlin, 1995.
Introduction. Der vorliegende Bericht ist
eine überarbeitete Fassung eines unveröffentlichten studentischen
Projektberichtes, der die Ergebnisse der Lehrveranstaltung
"Spezifizieren mit Graphgrammatiken und Petrinetzen" im Wintersemester
1993/94 darstellte. Thema dieses Projektes war die graphische
Spezifikation komplexer Softwaresysteme am Beispiel des Algebraischen
Graphgrammatiksystems AGG. Anhand dieses Beispieles sollte geprüft
werden, ob und wie sich algebraische Graphtransformationen und
Petrinetze zur Spezifikation von Softwaresystemen eignen. (cont'd)
 Reiko. Heckel, Jürgen Müller, Gabriele Taentzer, Annika Wagner:
Attributed Graph Transformations with Controlled Application of
Rules
in G. Valiente, F. Rossello Llompart (eds), Proc. Colloquium on Graph
Transformation and its Application in Computer Science. Technical
Report B  19, Universitat de les Illes Balears, 1995.
Abstract. We present a combination of
recent extensions to singlepushout graph transformations, as there are
attribution, application conditions and amalgamated graph
transformations and add a simple transaction concept on top of this
formalism. Thereby, we provide the formal basis for several examples,
where these concepts are used in combination.
 Gabriele Taentzer, Andy Schürr:
DIEGO, Another Step Towards a Module Concept for Graph
Transformation Systems
in Proc. of SEGRAGRA'95 "Graph Rewriting and Computation", Electronic
Notes of TCS}, 2, 1995, http://www.elsevier.nl/locate/entcs.
Abstract. DIEGO module systems offer
means for DIstributed programming with Encapsulated Graph Objects.
Their operational semantics definition follows the lines of distributed
graph transformation, thereby permitting the specification of
distributed systems with concurrently interacting objects. Adapting
previously made proposals for a graph grammar module concept and for
graph models with information hiding to this setting, the new approach
supports structuring of large specifications into small reusable
modules with welldefined interfaces between them. Use relations
between export interfaces and import interfaces are our means to
construct system architectures and to allow reuse of modules in
different environments.
 Hartmut Ehrig, Gabriele Taentzer:
Third Interim Report of ESPRIT Basic Research Working Group No.
7183: Computing by Graph Transformation II (COMPUGRAPH
II)
Technical Report 95  23, TU Berlin, 1995.
Abstract. This is a survey of the
main aims and results of the ESPRIT Basic Research Working Group
COMPUTING BY GRAPH TRANSFORMATION II, 1992  1996, following up the
first phase of COMPUGRAPH, 1989  1992. The research goals and main
results are presented within the following three research areas:
Foundations, Concurrency, and Graph Transformations for Specification
and Programming.
 Gabriele Taentzer, Martin Beyer:
Amalgamated Graph Transformations and Their Use for Specifying
AGG  an Algebraic Graph Grammar System
in H.J. Schneider, H.~Ehrig (eds.), Graph Transformations in Computer
Science, LNCS 776, Springer, 1994.
Abstract. The AGGsystem is a
prototype implementation of the algebraic approach to graph
transformation. It consists of a flexible graph editor and a
transformation component. The editor allows the graphical
representation of production rules, occurrences and transformation
results. The transformation component performs direct transformation
steps for userselected production rules and occurrences. First steps
towards a graph specification of an abstract version of the AGGsystem
are possible by using amalgamated graph transformations. AGGstates are
modelled by graphs whereas AGGoperations are described by amalgamated
graph transformations combining parallel and sequential rewriting of
graphs