Direkt zum Inhalt
 
 
Eine algebraische Fläche vom Grad 6 (eine "Sextik"), die 65 Singularitäten besitzt.
 
  Startseite  
 
Sie sind hier:» Universität » Mathematik und Informatik » Arbeitsgruppen » Softwaretechnik » Forschung » Publikationen
  • Print this page
  • create PDF file

Publications

2017 |2016 | 2015 | 2014 | 2013 | 2012 | 2011 | 2010 | 2009 | 2008 | 2007 | 2006 | 2005 | 2004 | 2003 | 2002 and before 


 

2017


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.

Conflict and dependency analysis (CDA) is a static analysis for the detection of conflicting and dependent rule applications in a graph transformation system. The state-of-the-art CDA technique, critical pair analysis, provides its users the benefits of completeness, i.e., its output contains a precise representation of each potential conflict and dependency in a minimal context, called critical pair. Yet, user feedback has shown that critical pairs can be hard to understand; users are interested in core information about conflicts and dependencies occurring in various combinations. In this paper, we investigate the granularity of conflicts and dependencies in graph transformation systems. We introduce a variety of new concepts on different granularity levels: We start with conflict atoms, representing individual graph elements as smallest building bricks that may cause a conflict. We show that each conflict atom can be extended to at least one conflict reason and, conversely, each conflict reason is covered by atoms. Moreover, we relate conflict atoms to minimal conflict reasons, representing smallest element sets to be overlapped in order to obtain a pair of conflicting transformations. We show how conflict reasons are related to critical pairs. Finally, we introduce dual concepts for dependency analysis. As we discuss in a running example, our concepts pave the way for an improved CDA technique.

Rule-based Repair of EMF Models: An Automated Interactive Approach.
International Conference on Model Transformation (ICMT) 2017

Abstract.

Managing and resolving inconsistencies in models is crucial in model-driven engineering (MDE). In this paper we consider models that are based on the Eclipse Modeling Framework (EMF). We propose a rule-based approach to support the modeler in automatically trimming and completing EMF models and thereby resolving their cardinality violations. Although being under repair, the model may be viewed and changed interactively during this repair process. The approach and the developed tool support are based on EMF and the model transformation language Henshin.

Rule-based Repair of EMF Models: Formalization and Correctness Proof.
Eighth International Workshop on Graph Computation Models (GCM) 2017

Abstract.

In model-driven engineering (MDE), resolving model inconsistencies in a semi-interactive way promises to increase the productivity and quality of software development. In this paper, we discuss properties of an approach for model repair: The proposed algorithm can trim and complete models based on the Eclipse Modeling Framework (EMF), and thereby resolve their cardinality violations. We use rules, as defined in the theory of algebraic graph transformation, to declare the different actions executed during the particular steps of the algorithm. This formal background is used to reason for the correctness of the algorithm and to present conditions under which it always terminates. Possible adaptions of and more general use cases for the algorithm are discussed.

Iterative Model-Driven Development of Software Extensions for Web Content Management Systems.
European Conference on Modelling Foundations and Applications (ECMFA) 2017

Abstract.

Dynamic web applications powered by Web Content Management Systems (WCMSs) such as Joomla, WordPress, or Drupal dominate today's web. A main advantage of WCMSs is their functional extensibility by standardized WCMS extensions. However, the development and evolution of these extensions are challenging tasks. Due to dependencies to the core platform and other WCMS extensions, the code structure of an extension includes a large defect potential. Mistakes usually lead to website crashes and are hard to find, especially for inexperienced developers. In this work, we define a model-driven development (MDD) process and apply it during the development of software extensions for the WCMS Joomla. To address two separate scenarios, involving the development of independent and dependent WCMS extensions, we use an MDD infrastructure, comprising a domain-specific language, a code editor, and reverse engineering facilities. In addition, we provide evidence indicating that our model-driven approach is useful to generate extensions with consistent interdependencies, demonstrating that the main issues of extension development in the WCMS domain can be addressed using a model-driven approach. By applying the MDD infrastructure on actual projects, we additionally present the lessons learned.

Henshin: A Usability-Focused Framework for EMF Model Transformation Development
International Conference on Graph Transformation (ICGT) 2017

Abstract.

Improved usability of tools is a fundamental prerequisite for a more widespread industrial adoption of Model-Driven Engineering. We present the current state of Henshin, a model transformation language and framework based on algebraic graph transformations. Our demonstration focuses on Henshin’s novel usability-oriented features, specifically: (i) a textual syntax, complementing the existing graphical one by improved support for rapid transformation development, (ii) extended static validation, including checks for correct integration with generalpurpose-language code, (iii) advanced refactoring support, in particular, for splitting large transformation programs, (iv) editing utilities for facilitating recurring tasks in model transformation development. We demonstrate the usefulness of these features using a running example.

Change-Preserving 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 meta-model 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 state-based, (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 re-establish 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.

 

2016


A text-based visual notation for the unit testing of model-driven tools.
Computer Languages, Systems and Structures

Abstract.

During the unit testing of model-driven tools, a large number of models and test classes needs to be managed and maintained. Typically, some of these artifacts are specified manually, some are generated automatically. Existing approaches to test management rely on the available visual and textual modeling notations. As these notations are not tailored to unit testing, distinct maintainability trade-offs arise. In this paper, we propose a notation that aims to combine the benefits of visual and text-based approaches. The notation is at the same time visual and text-based, as it uses ASCII characters to emulate the familiar graphical notations. In our evaluation based on real models, we identify problematic model shapes challenging the scalability our notation, while finding that it is well-suited to capture typical test models.

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.

This paper presents a solution to the TTC2016 challenge ”The Class Responsibility Assignment Case”. Our solution uses the Henshin model transformation language to specify genetic operators in a standard genetic algorithm framework. Due to its formal foundation based on algebraic graph transformations, Henshin is well-suited to specify fundamental change patterns for genetic operators in a declarative manner. Adopting a simple, widely used genetic algorithm, we focus on effective implementation strategies for the genetic operators as well as additional operations. We analyzed our implemented strategies on the given evaluation criteria, finding a drastic impact of some configuration options on the runtime and quality of its results.

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.

Model transformation systems often contain families of rules that are substantially similar to each other. Variability-based rules are a recent approach to express such families of rules in a compact representation, enabling the convenient editing of multiple rule variants at once. On the downside, this approach gives rises to distinct maintenance drawbacks: Users are required to view and edit presence conditions. The complexity and size of the resulting rules may impair their readability. In this paper, we propose to facilitate the editing of variability-based rules through suitable tool support. Inspired by the paradigms of filtered editing and virtual seperation of concerns, we present a tool environment that offers editable views for variants expressed in a variability-based rule. We demonstrate that our tool environment is helpful to address the identified issues, rendering variability-based rules a highly feasible reuse approach.

Clone Detection for Graph-Based Model Transformation Languages. Awarded with the Best Paper Award
International Conference on Model Transformation (ICMT) 2016

Abstract.

Cloning is a convenient mechanism to enable reuse across and within software artifacts. On the downside, it is also a practice related to significant long-term maintainability impediments, thus generating a need to identify clones in affected artifacts. A large variety of clone detection techniques has been proposed for programming and modeling languages; yet no specific ones have emerged for model transformation languages. In this paper, we explore clone detection for graph-based model transformation languages. We introduce potential use cases for such techniques in the context of constructive and analytical quality assurance. From these use cases, we derive a set of key requirements. We describe our customization of existing model clone detection techniques allowing us to address these requirements. Finally, we provide an experimental evaluation, indicating that our customization of ConQAT, one of the existing techniques, is well-suited to satisfy all identified requirements.

Automatically Deriving the Specification of Model Editing Operations from Meta-Models.
International Conference on Model Transformation (ICMT) 2016

Abstract.

To optimally support continuous model evolution in model-based software development, adequate tool support for model version management is needed. Instead of reporting model differences to the developer line-by-line or element-wise, their grouping into semantically associated change sets helps in understanding model differences. Edit operations are the concept of choice to group such change sets. Considering visual models in particular, edit operations preserve a basic form of consistency such that changed models can still be viewed in a standard editor. Using edit operations for the version management of domain-specific models requires tool developers to specify all necessary edit operations in order to produce or replicate every possible change on a model. However, edit operations can be numerous and their manual specification is therefore tedious and error-prone. In this paper, we present a precise approach to specify a complete set of consistency-preserving edit operations for a given modeling language. The approach is supported by a generator and has been evaluated in four case studies covering several visual modeling languages and standard editors.

Perspectives of Model Transformation Reuse.
International Conference on Integrated Formal Methods (iFM) 2016

Abstract.

Model Transformations have been called the “heart and soul” of Model-Driven software development. However, they take a lot of effort to build, verify, analyze, and debug. It is thus imperative to develop good reuse strategies that address issues specific to model transformations. Some of the effective reuse strategies are adopted from other domains, specifically, programming languages. Others are custom developed for models. In this paper, we survey techiques from both categories. Specifically, we present two techniques adoped from the PL world: subtyping and mapping, and then two techniques, lifting and aggregating, that are novel in the modeling world. Subtyping is a way to reuse a transformation for different - but similar - input modelling languages. Mapping a transformation designed for single models reuses it for model collections, such as megamodels. Lifting a transformation reuses it for aggregate representations of models, such as product lines. Aggregating reuses both transformation fragments (during transformation creation) and partial execution results (during transformation execution) across multiple transformations. We then point to potential new directions for research in reuse that draw on the strengths of the programming and the modeling worlds.

An Algorithm for the Critical Pair Analysis of Amalgamated Graph Transformations.
International Conference on Graph Transformation (ICGT) 2016

Abstract.

Graph transformation has been shown to be well suited as formal foundation for model transformations. While simple model changes may be specified by simple transformation rules, this is usually not sufficient for more complex changes. In these situations, the concept of amalgamated transformation has been increasingly often used to model for each loops of rule applications which coincide in common core actions. Such a loop can be specified by a kernel rule and a set of extending multi-rules forming an interaction scheme. The Critical Pair Analysis (CPA) can be used to show local confluence of graph transformation systems. Each critical pair reports on a potential conflict between two rules. It has been shown recently that the generally infinite set of critical pairs for interaction schemes can be reduced to a finite set of non-redundant pairs being sufficient to show local confluence of the transformation system. Building on this basic result, we present an algorithm that is able to compute all non-redundant critical pairs for two given interaction schemes. The algorithm is implemented for Henshin, a model transformation environment based on graph transformation concepts.

Model-Driven Development of Mobile Applications: Towards Context-Aware Apps of High Quality.
International Workshop on Petri Nets and Software Engineering (PNSE) 2016: 17-29

Abstract.

Rapidly increasing numbers of applications and users make the development of mobile applications to one of the most promising fields in software engineering. Due to short time-to-market, differing platforms and fast emerging technologies, mobile application development faces typical challenges where model-driven development (MDD) can help. An infrastructure for MDD has a high potential for accelerating the development of software applications. While just modeling the applicationspecific data structures, processes and user interfaces, runnable apps can be generated for multiple platforms such as Android and iOS. Hence, MDD can lift software development to a higher abstraction level leaving all technical details to the generators. Moreover, the domain-specific model of a mobile application can be the starting point for validation and verification based on formal models. In this paper, we consider the state-of-the-art in MDD of mobile applications and consider future research directions such as the MDD support for higher mobility in changing contexts, a combination of sensors, and augmented reality. Moreover, we discuss quality assurance of mobile applications.

Model-Driven Process to Migrate Web Content Management System Extensions.
International Conference on Web Engineering (ICWE) 2016, Posters

Abstract.

Developing and maintaining software extensions for Web Content Management Systems (WCMSs) like Joomla, WordPress, or Drupal can be a difficult and time consuming process. This poster presents a model-driven process which addresses typical challenges during the migration of software extensions for WCMSs. We introduce JooMDD as a prototypical environment for the development and maintenance of Joomla extensions. JooMDD consists of a domain-specific modelling language for WCMS extensions, a reverse engineering tool to create models based on existing WCMS extensions, and a code generator for software extensions, which can be used to enrich Joomla-based applications. The use of JooMDD within our research demonstrates the application of a model-driven migration process for WCMS extensions.

JooMDD: A Model-Driven Development Environment for Web Content Management System Extensions.
International Conference on Software Engineeing (ICSE) 2016, Demonstrations

Abstract.

Developing software extensions for Web Content Management Systems (WCMSs) like Joomla, WordPress, or Drupal can be a difficult and time consuming process. In this demo we present JooMDD, an environment for model-driven development of software extensions for the WCMS Joomla. JooMDD allows the rapid development of standardised software extensions requiring reduced technological knowledge of Joomla. This implies that even inexperienced developers are able to create their own functional WCMS extensions. This demonstrates that a model-driven approach is suitable for the domain of WCMSs. A supporting video illustrating the main features and a demonstration of JooMDD can be found at: https://youtu.be/Uy_WBIjPldI.

A Generic Architecture Supporting Context-Aware Data and Transaction Management for Mobile Applications.
3rd IEEE/ACM International Conference on Mobile Software Engineering and Systems

Abstract.

Mobile applications claim to operate reliably during spatial movement, however, developers have to deal with the effects of changing environmental contexts. One of the most important contexts is the connectivity of mobile devices. Since mobile applications are increasingly used as front-ends of transaction systems, they have to be designed for being able to deal with intentional or accidental loss of connection. In fact, we find a lot of mobile applications being not more than portable because they cannot operate without connections.
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 context-aware architectures of mobile applications. We present a generic architecture supporting users to effectively use applications on-line as well as off-line. This approach enables the concurrent execution of off-line transactions as well as their durability after synchronization. Starting from example applications, we analyze the design of existing context-aware 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.

The use of model-based software development has become more and more popular because it aims to increase the quality of software development. Therefore, the number and the size of model instances are cumulatively growing and software quality and quality assurance consequently lead back to the quality and quality assurance of the involved models. For model quality assurance, several quality aspects can be checked by the use of dedicated metrics. However, when using a domain specific modeling language, the manual creation of metrics for each specific domain is a repetitive and tedious process. In this paper, we present an approach to derive basic model metrics for any given modeling language by defining metric patterns typed by the corresponding meta-meta model. We discuss several concrete patterns and present an Eclipse-based tool which automates the process of basic model metrics derivation, generation, and calculation.

RuleMerger: Automatic Construction of Variability-Based Model Transformation Rules.
Fundamental Approaches to Software Engineering (FASE) 2016

Abstract.

Unifying similar model transformation rules into variability-based 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 error-prone task. In this paper, we propose a novel merge-refactoring 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 state-of-the-art 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 high-quality outcomes in two real-life case-studies.


Model-Driven Development of Platform-Independent MobileApplications Supporting Role-based App Variability.
Software Engineering 2016

Abstract.

The use of mobile applications has become an indispensable part of human interaction and especially of urban life. This will lead to rapidly increasing numbers of applications and users that make the development of mobile applications to one of the most promising fields in software engineering. Due to short time-to-market, differing platforms and fast emerging technologies, mobile application development faces typical challenges where model-driven development (MDD) can help.We present a modeling language and an infrastructure for the model-driven development of native apps in Android and iOS. Our approach allows flexible app development on different abstraction levels: compact modeling of standard app elements such as standard data management and increasingly detailed modeling of individual elements to cover specific behavior. Moreover, a kind of variability modeling is supported such that apps variants for a range of user roles can be developed. Several apps including a mobile learning app, a conference app, and a museum guide with augmented reality functionality demonstrate the usefulness of our approach.

Model-Driven Engineering in the Large: Refactoring Techniques for Models and Model Transformation Systems.
Dissertation, Philipps-Universität Marburg, 2016

Abstract.

Model-Driven 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 large-scale 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 large-scale system development, models are created using various domain-specific 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 sub-models. The aim of this technique is to enable a separation of concerns within models, promoting a concern-based 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 variability-based 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 real-world settings.


2015


MUTANT: Model-Driven Unit Testing using ASCII-art as Notational Text.
FlexMDE Workshop: 2-11

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 ASCII-art - a text-based 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 reuse-intensive settings.


Agile bottom-up development of domain-specific IDEs for model-driven development.
FlexMDE Workshop: 12-21

Abstract.

Diminishing time-to-market and rapidly evolving technology stacks stretch traditional software development methods to their limits. In this paper, we propose a novel process for bottom-up development of domain-specific IDEs based on agile principles. It aims to enable a fine-grained co-evolution of domain-specific modeling languages (DSMLs) and their model editors and code generators. We illustrate our approach by iteratively developing an IDE for model-driven 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.


An Adaptable Tool Environment for High-level Differencing of Textual Models.
OCL and Textual Modeling Workshop

Abstract.

The use of textual domain-specific modeling languages is an important trend in model-driven 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 high-level 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.


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 multi-rules 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.


Multi-Amalgamated Triple Graph Grammars.
International Conference on Graph Transformation

Abstract.

Triple Graph Grammars (TGGs) are a well-known technique for rule-based 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 multi-amalgamation concept from classical graph transformation into TGGs. Multi-Amalgamation 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 loop-like manner depending on concrete models at transformation time.


Translating Essential OCL Invariants to Nested Graph Constraints Focusing on Set Operations.
International Conference on Graph Transformation

Abstract.

Domain-specific modeling languages (DSMLs) are usually defined by meta-modeling 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 meta-modeling 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 meta-model 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.


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.


Analyzing Conflicts and Dependencies of Rule-Based Transformations in Henshin. (Extended Version: Tool Demonstration)
Fundamental Approaches to Software Engineering (FASE) 2015: 165-168

Abstract.

Rule-based model transformation approaches show two kinds of non-determinism: (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).


A Variability-Based Approach to Reusable and Efficient Model Transformations. (Extended Version: Technical Report)
Fundamental Approaches to Software Engineering (FASE) 2015: 283-298

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 variability-based graph transformations. We formally define variability-based rules and contribute a novel match-finding 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 speed-up on a realistic transformation scenario.


2014


A Static Analysis of Non-Confluent Triple Graph Grammars for Efficient Model Transformation. Awarded with the Best Paper Award
Graph Transformations (ICGT) 2014: 130-145

Abstract.

Triple Graph Grammars (TGGs) are a well-known 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 non-confluent 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 well-known transformation of constraints to application conditions, we present a static analysis that guarantees dead end-freeness for non-confluent TGGs.


From Core OCL Invariants to Nested Graph Constraints. (Long Version)
Graph Transformations (ICGT) 2014: 97-112

Abstract.

Meta-modeling including the use of the Object Constraint Language (OCL) forms a well-established approach to design domain-specific 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 meta-models with Core OCL invariants and translate them to nested graph constraints for typed attributed graphs. Models and meta-models 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 meta-modeling 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.


Model-Driven Development of Mobile Applications Allowing Role-Driven Variants.
International Conference on Model Driven Engineering Languages and Systems (MODELS) 2014: 1-17

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 time-to-market, differing platforms and fastly emerging technologies, mobile application development faces typical challenges where model-driven development can help. We present a modeling language and an infrastructure for the model-driven 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.


Tool Support for Model Splitting using Information Retrieval and Model Crawling Techniques.
Workshop on Scalability in Model Driven Engineering (BigMDE) 2014: 44-47

Abstract.

To facilitate the collaboration in large-scale modeling scenarios, it is sometimes advisable to split a model into a set of sub-models 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 post-processing the generated splitting suggestions. We preliminarily evaluate the tool in a case study involving a real-life model.


Splitting Models Using Information Retrieval and Model Crawling Techniques.
Fundamental Approaches to Software Engineering (FASE) 2014: 47-62

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 sub-models. We propose an approach that assists users in iteratively discovering the set of desired sub-models. 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 real-life case studies, involving UML class models and EMF meta-models.  


Quality Assurance of Software Models - A Structured Quality Assurance Process Supported by a Flexible Tool Environment in the Eclipse Modeling Project.
Dissertation, Philipps-Universität Marburg, 2014

Abstract.

The paradigm of model-based 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 syntax-oriented process for quality assurance of software models that can be adapted to project-specific and domain-specific needs. It is structured into two sub-processes: a process for the specification of project-specific 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 well-known 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 proof-of-concept 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 high-level quality attributes and low-level 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 model-based 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 tree-based EMF instance editors, graphical GMF-based 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 syntax-oriented model quality assurance process.


  • Florian Mantz:

Coupled Transformations of Graph Structures applied to Model Migration.
Dissertation, Philipps-Universität Marburg, 2014

Abstract.

Model-Driven 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 co-adopted (migrated) to language changes. This migration should be automated, as migrating models manually is time consuming and error-prone. While application modelers use ad-hoc solutions to migrate their models, there is still a lack of theory to ensure well-defined 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.


2013


A tool environment for quality assurance based on the Eclipse Modeling Framework.
Autom. Softw. Eng. 20(2): 141-184 (2013)

Abstract.

The paradigm of model-based 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 project-specific and domain-specific 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 model-based software development. 


Co-Transformation of Type and Instance Graphs Supporting Merging of Types and Retyping.
ECEASST 61 (2013)

Abstract.

Algebraic graph transformation is a well-known rule-based approach to manipulate graphs that can be applied in several contexts. In this paper we use it in the context of model-driven engineering. Graph transformation rules usually specify changes to only one graph per application, however there are use cases such as model co-evolution where not only a single graph should be manipulated but also related ones. The co-transformation of type graphs together with their instance graphs has shown to be a promising approach to formalize model and meta-model co-evolution. In this paper, we extend our earlier work on co-evolution by allowing transformation rules that have less restrictions so that graph manipulations such as merging of types and retyping of graph elements are allowed.


Tool Support for Clustering Large Meta-Models.
Workshop on Scalability in Model Driven Engineering (BigMDE) 2013: Paper No. 7

Abstract.

Ever-growing requirements, long-term evolution and modernization of software projects lead to meta-models of remarkable size, being difficult to comprehend and maintain. This paper presents a tool that supports the decomposition of a meta-model 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 meta-models. An evaluation of the tool is provided in terms of a case study.


Towards a Distributed Modeling Process Based on Composite Models.
Fundamental Approaches to Software Engineering (FASE) 2013: 6-20

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.


Customizing model migrations by rule schemes.
IWPSE 2013: 1-10

Abstract.
Model-driven 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 model-to-code 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 meta-models evolve which means that existing models have to be migrated correspondingly. In our approach, such co-evolutions are specied as related graph transformations ensuring welltyped model migration results. Based on our earlier work on co-transformations, we now consider the automatic deduction of migration rule schemes from given meta-model 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 co-evolution examples are discussed. 


2012


A fundamental approach to model versioning based on graph modifications: from theory to implementation.
Software and Systems Modeling (2012)

Abstract.

Meta modeling is a wide-spread 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 large-scale 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 meta-models by type graphs with multiplicities and introduce instance-generating 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 meta-modeling approach.


Instance Generation from Type Graphs with Arbitrary Multiplicities.
ECEASST 47 (2012)

Abstract.

Meta modeling is a wide-spread 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 large-scale 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 meta-models by type graphs with multiplicities and introduce instance-generating 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 meta-modeling approach.


Transformation of Typed Composite Graphs with Inheritance and Containment Structures.
Fundam. Inform. 118(1-2): 97-134 (2012)

Abstract.

Model-driven development (MDD) has become a promising trend in software engineering. The model-driven 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 model-driven development. This is done based on the formal foundation of distributed graphs. Moreover, this category-theoretical foundation allows for the precise definition of consistent composite graph transformations satisfying all inheritance and containment conditions.


Formal foundation of consistent EMF model transformations by algebraic graph transformation.
Software and System Modeling 11(2): 227-250 (2012)

Abstract.

Model transformation is one of the key activities in model-driven 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 multi-object structures. Rules extended by multi-object 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.


Integrating the Specification and Recognition of Changes in Models.
Softwaretechnik-Trends 32(2) (2012)

Abstract.

Model-based software development has become a widely accepted approach in application domains where software is long-living 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 low-level operations on models, which are sometimes incomprehensible for users. Thus, both classes of tools should be better integrated and extended to supporting high-level edit operations, e.g. refactoring operations. 


Co-transformation of Graphs and Type Graphs with Application to Model Co-evolution.
ICGT 2012: 326-340

Abstract.

Meta-modeling has become the key technology to define do–main-specific modeling languages in model-driven engineering. Since do–main-specific modeling languages often change quite frequently, concepts are needed for the coordinated evolution of their meta-models as well as of their models, and possibly other related artifacts. In this paper, we present a new approach to the co-transformation of graphs and type graphs and show how it can be applied to model co-evolution. This means that models are specified as graphs while model relations, especially type-instance relations, are defined by graph morphisms specifying type conformance of models to their meta-models. Hence, meta-model evolution and accompanying model migrations are formally defined by co-transformations of instance and type graphs. In our approach, we clarify the type conformance of co-transformations, 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.


Construction of Integrity Preserving Triple Graph Grammars. Awarded with the Best Paper Award
ICGT 2012: 356-370

Abstract.

Triple Graph Grammars (TGGs) are a rule-based 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 well-known 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.


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, Philipps-Universität Marburg, 2012

Abstract.

Model-driven 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, so-called components, and let distributed teams work on each concurrently. The question arises how this strategy can be applied to model-driven 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 so-called 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 category-theoretical 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.


2011



A rule-based approach to the semantic lifting of model differences in the context of model versioning. 
ASE 2011: 163-172


Abstract.
In model-based 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 technology-dependent runtime representation and will initially derive low-level changes, which can differ considerably from user-level editing commands. Low-level 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 rule-based approach to this problem: low-level differences are represented based on the Eclipse Modeling Framework. They are transformed into representations of editing operations using a rule-based model transformation engine. The necessary transformation rules are automatically derived from basic transformation rules for the editing operations.



A Formal Resolution Strategy for Operation-Based Conflicts in Model Versioning Using Graph Modifications.
FASE 2011: 202-216

Abstract.
In model-driven 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 model-driven engineering. In contrast to text-based 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  GBeschreibung: http://www.springerlink.com/jsMath/fonts/cmsy10/alpha/120/char20.png-D-Beschreibung: http://www.springerlink.com/jsMath/fonts/cmsy10/alpha/120/char21.pngH, 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 Local-Church-Rosser 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 delete-insert conflicts insertion has priority over deletion.


Towards Syntactical Model Quality Assurance in Industrial Software Development: Process Definition and Tool Support.
Software Engineering 2011: 63-74

Abstract.
The paradigm of model-based 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 Eclipse-based tools which support the main tasks of the proposed model quality assurance process.


Modeling with Plausibility Checking: Inspecting Favorable and Critical Signs for Consistency between Control Flow and Functional Behavior. 
FASE 2011: 156-170

Abstract.
UML activity diagrams are a wide-spread modelling technique to capture behavioral aspects of system models. Usually, pre- and post-conditions 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 semi-formal 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 plug-in for editing, simulating and analyzing integrated behavior models. It visualizes favorable and critical signs for consistency in a convenient way and uses the well-known 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.


Guest editorial: special issue on selected topics in automated software engineering - Specification mining and defect detection.
Autom. Softw. Eng. 18(3-4): 225-226 (2011)


No Abstract.


2010


EMF Refactor: Specification and Application of Model Refactorings within the Eclipse Modeling Framework.
9th edition of the BENEVOL workshop, Lille, France. (2010)


EMF Metrics: Specification and Calculation of Model Metrics within the Eclipse Modeling Framework.
9th edition of the BENEVOL workshop, Lille, France. (2010)


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)


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 20-28, 2010. Springer 2010


Parallel Independence of Amalgamated Graph Transformations Applied to Model Transformation.
Graph Transformations and Model-Driven 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 multi-rules modeling elementary actions and a common kernel rule for their synchronization (amalgamation). The amalgamation theorem by Böhm et al. ensures that for two multi-rules, 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 multi-rules. As example, we specify an excerpt of a model transformation from Business Process Models (BPM) to the Business Process Execution Language (BPEL).


A Component Concept for Typed Graphs with Inheritance and Containment Structures.
International Conference on Graph Transformation (2010): 187-202

Abstract.
Model-driven development (MDD) has become a promising trend in software engineering. The model-driven 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 category-theoretical 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.


Conflict Detection for Model Versioning Based on Graph Modifications.
International Conference on Graph Transformation (2010): 171-186

Abstract.
In model-driven 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 model-driven engineering. In contrast to text-based 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 rule-based. Building up on the DPO approach to graph transformations, we define two different kinds of conflict detection: (1) the check for operation-based conflicts, and (2) the check for state-based conflicts on results of merged graph modifications.


Henshin: Advanced Concepts and Tools for In-Place EMF Model Transformations.
Model Driven Engineering Languages and Systems Part I (2010): 121-135

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 in-place transformations of EMF models. The Henshin transformation language uses pattern-based rules on the lowest level, which can be structured into nested transformation units with well-defined operational semantics. So-called amalgamation units are a special type of transformation units that provide a forall-operator 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 meta-model evolution.


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 model-driven 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 multi-object structures. Multi-object 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 AND-states.


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 model-driven 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:

Introduction to AGG and EMF Tiger by modeling a Conference Scheduling System.
STTT 12(3-4): 245-261 (2010)

Abstract.
In this paper, we focus on the  Conference Scheduling System, a case study at the Tool Contest ofGraph-Based Tools (GraBaTs) 2008. We took part in the contest with our graph transformation tool AGG and the Eclipse-based 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.


2009


Model Refactoring in Eclipse by LTK, EWL, and EMF Refactor: A Case Study
MoDSE-MCCM 2009 Workshop.

Abstract.  Since model-driven 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.


Object Flow Definition for Refined Activity Diagrams
FASE 2009: 49-63, SpringerLink 2009 - Springer Berlin/Heidelberg.

Abstract.  Activity diagrams are a well-known 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 post-conditions 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 service-based on-line university calendar.


Towards Composite Model Transformations Using Distributed Graph Transformation Concepts
MoDELS 2009: 226-240.

Abstract.  Model-based 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: 55-62.

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.


Generating instance models from meta models
Software and System Modeling 8(4): 479-500 (2009).

Abstract.  Meta modeling is a wide-spread 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 large-scale 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 instance-generating graph grammars for creating instances of meta models, thereby overcoming the main deficit of the meta modeling approach for defining languages.


Analysis of Aspect-Oriented Model Weaving
Transitions on Aspect-Oriented Software Development 5: 235-263 (2009).

Abstract.  Aspect-oriented 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 aspect-oriented 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 use-case driven approach. Activities that are used to refine use-cases are the join points to compose cross-cutting 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 rule-based transformations. This theory is used to effectively reason about potential interactions and inconsistencies caused by aspect-oriented 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.


2008


Proceedings of the 4th International Conference on Graph Transformation, ICGT 2008, Leicester, United Kingdom, Proceedings Springer 2008.


Sufficient criteria for consistent behavior modeling with refined activity diagrams: Long version
Technical Report 2008-11, Technische Universität Berlin, 2008.

Abstract.  In use case-driven approaches to requirements modeling, UML activity diagrams are a wide-spread means for refining the functional view of use cases. Early consistency validation of activity diagrams is therefore desirable but difficult due to the semi-formal nature of activity diagrams. In this paper, we specify well-structured 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 post-conditions allows us to establish sufficient criteria for consistency. The semi-automatic checking of these criteria is supported by a tool for graph transformation.


Construction of Consistent Models in Model-Driven Software Development
Ralf-Detlef Kutsche and Nikola Milanovic (eds.)
Model-Based Software and Data Integration, First International Workshop, MBSDI 2008, Berlin, Germany.
Springer-Verlag Berlin Heidelberg 2008, Communications in Computer and Information Science.

Abstract.  Model-driven 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 model-driven 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.


Third international workshop on graph and model transformations
ICSE Companion 2008: 1055-1056.


Model-Driven Software Refactoring

Jörg Rech and Christian Bunse (eds.):
Model-Driven Software Development: Integrating Quality Assurance, IGI Global, 2008.



Sufficient Criteria for Consistent Behavior Modeling with Refined Activity Diagrams
MoDELS 2008: 341-355.

Abstract.  In use case-driven approaches to requirements modeling, UML activity diagrams are a wide-spread means for refining the functional view of use cases. Early consistency validation of activity diagrams is therefore desirable but difficult due to the semi-formal nature of activity diagrams. In this paper, we specify well-structured 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 post-conditions allows us to establish sufficient criteria for consistency. The semi-automatic checking of these criteria is supported by a tool for graph transformation.


Precise Semantics of EMF Model Transformations by Graph Transformation
MoDELS 2008: 53-67.

Abstract.  Model transformation is one of the key activities in model-driven 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.


Sufficient Criteria for Applicability and Non-Applicability of Rule Sequences
ECEASST 10 (2008).

Abstract.  In several rule-based 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 non-applicability. 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).


A Typed Attributed Graph Grammar with Inheritance for the Abstract Syntax of UML Class and Sequence Diagrams
Electr. Notes Theor. Comput. Sci. 211: 261-269 (2008).

Abstract.  According to the UML Standard 2.0 class and sequence diagrams are defined in a descriptive way by a MOF meta-model and semi-formal constraints. This paper presents a formal and constructive definition of the abstract syntax of UML class and sequence diagrams based on the well-defined 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 well-established 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.


Translation of Restricted OCL Constraints into Graph Constraints for Generating Meta Model Instances by Graph Grammars
Electr. Notes Theor. Comput. Sci. 211: 159-170 (2008).

In Proc. International Workshop on Graph Transformation and Visual Modeling Techniques (GT-VMT'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 well-formedness rules, which could be formalized by OCL, the abstract syntax of visual modeling techniques is defined in a declarative way. Since meta-modeling is non-constructive, 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 large-scale testing. In our approach, an instance-generating 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, well-formedness 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.


Maintaining Coherence Between Models With Distributed Rules: From Theory to Eclipse
Electr. Notes Theor. Comput. Sci. 211: 87-98 (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 re-engineering 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.


2007


  • Enrico Biermann, André Crema, Karsten Ehrig, Claudia Ermel, Christian Köhler, René Schmutzler and Gabriele Taentzer:

Extending GMF: Generating Domain-Specific Model Editors with Complex Editing Commands
Eclipse Summit Europe 2007: The Modeling Symposium.


Analysis of Aspect-Oriented Model Weaving
SpringerLink 2007 - Springer Berlin/Heidelberg , 0302-9743 (Print), 1611-3349 (Online), Volume 5490/2009.

Abstract.  Aspect-oriented 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 aspect-oriented 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 use-case driven approach. Activities that are used to refine use-cases are the join points to compose cross-cutting 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 rule-based transformations. This theory is used to effectively reason about potential interactions and inconsistencies caused by aspect-oriented 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.


Specifying Domain-Specific Refactorings for AndroMDA Based on Graph Transformation
AGTIVE 2007: 104-119.

Abstract.  Applying refactoring in a model-driven software engineering context raises many new challenges that need to be addressed. In this paper, we consider model-driven software development based on the code generation framework AndroMDA. Considering the UML profile for AndroMDA, we come up with a number of domain-specific 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 domain-specific refactorings can be specified by EMF transformation incorporating graph transformation concepts. This opens up the possibility to reason about domain-specific 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: 493-513.

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.


AGTIVE 2007 Graph Transformation Tool Contest
AGTIVE 2007: 487-492.

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: 514-539.

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 well-known 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: 566-567.

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.


Generating Eclipse Editor Plug-Ins Using Tiger
AGTIVE 2007: 583-584.

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 plug-in based on the Eclipse Graphical Editing Framework (GEF).


Generating Domain-Specific Model Editors with Complex Editing Commands
AGTIVE 2007: 98-103.

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 domain-specific 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.


Information Preserving Bidirectional Model Transformations
FASE 2007: 72-86.

Abstract.  Within model-driven 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 application-oriented 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.


Ensuring Containment Constraints in Graph-based 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 metamodel-defined 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 MOF-based languages and imply a couple of constraints which must be ensured in model transformation approaches. Based on a double-pushout 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.


Analysing refactoring dependencies using graph transformation
Software and System Modeling 6 (3): 269-285 (2007), Springer.

Abstract.  Refactoring is a widely accepted technique to improve the structure of object-oriented 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): 139-163 (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 meta-modelling. 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.


2006



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 domain-specific 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) model-level 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 plug-ins generate stand-alone 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 model-driven 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 In-Place 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 rule-based modification of EMF models is still missing. In this paper we present a framework for in-place 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.



Maintaining Coherence between Models with Distributed Rules: from Theory to Eclipse
In Proc. International Workshop on Graph Transformation and Visual Modeling Techniques (GT-VMT'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.


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 high-level 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 Church-Rosser, Parallelism, Concurrency, Embedding and Extension Theorem and a Local Confluence Theorem known as Critical Pair Lemma in the literature.


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 rule-based 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, so-called adhesive high-level 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.


Generating Instance Models from Meta Models
8th IFIP International Conference on Formal Methods for Open Object-Based Distributed Systems (FMOODS'06), Bologna, Italy, June 2006.

Abstract.  Meta modeling is a wide-spread 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 large-scale 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 instance-generating graph grammars for creating instances of meta models, thereby overcoming the main deficit of the meta modeling approach for defining languages.


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 domain-specific 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) model-level 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 plug-ins generate stand-alone transformer programs in Java which are responsible for model manipulation.


Object Oriented and Rule-based Design of Visual Languages using TIGER
Proc. Third International Workshop on Graph-Based Tools (GraBaTs'06), volume1, Natal, Brazil, September 2006, Electronic Communications of the EASST.

Abstract.  In this paper we present the state-of-the-art of the TIGER environment for the generation of visual editor plug-ins in Eclipse, with the focus on its Designer component, a visual environment for object oriented and rule-based 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 plug-in. For the graphical layout we use the Graphical Editing Framework (GEF) of ECLIPSE which offers an efficient and standardized way for graphical layouting.


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 (GT-VMT'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 meta-model and semi-formal constraints. This paper presents a formal and constructive definition of the abstract syntax of UML class and sequence diagrams based on the well-defined 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 well-established 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.


Evolutionary layout: preserving the mental map during the development of class models
SOFTVIS 2006: 165-166.


Evolutionary Layout of Graph Transformation Sequences
In Proc. Third International Workshop on Graph-Based 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 well-known 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.


Interaction Analysis in Aspect-Oriented Models
Proc. 14th IEEE International Requirements Engineering Conference, pages 66–75, Minneapolis, Minnesota, USA, September 2006. IEEE Computer Society.

Abstract.  Aspect-oriented 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 aspect-oriented separation of cross-cutting 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 use-case driven approach. Activities, which are used to refine use cases, are the join points to compose cross-cutting 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 rule-based 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.


Analysing refactoring dependencies using graph transformation
Software and System Modeling, 2006

Abstract.  Refactoring is a widely accepted technique to improve the structure of object-oriented 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.


A graph-based 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 graph-based approach to simplify the transformation definition process where graphs representing documents are transformed in a rule-based 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, graph-based transformation definitions can be automatically reversed in most cases. This is especially useful in model transformation (e.g. in OMG's MDA approach).


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 Meta-CASE 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 Domain-Specific Model Editors with Complex Editing Commands

In Proc. International Workshop Eclipse Technology eXchange (eTX)
Satellite Event of European Conf. on Object-Oriented 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 domain-specific 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 domain-specific 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, syntax-directed 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 post-conditions of each command. The background for this approach is the grammar-based 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 model-based editor specification extended by such rules shall be used to generate Eclipse plug-ins for domain-specific editing with complex editing commands.


Simulation and Animation of Visual Models of Embedded Systems: A Graph-Transformation-Based Approach Applied to Petri Nets

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 domain-specific 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 model-driven 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.


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 (GT-VMT'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 well-formedness rules, which could be formalized by OCL, the abstract syntax of visual modeling techniques is defined in a declarative way. Since meta-modeling is non-constructive, 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 large-scale testing. In our approach, an instance-generating 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, well-formedness 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.


2005


High-Level 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 high-level replacement systems, a generalization of graph transformation systems. For high-level replacement units, we state and prove several abstract properties based on termination criteria. Then, we instantiate the high-level 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.


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 pre-conditions 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.


Formal Integration of Inheritance with Typed Attributed Graph Transformation for Efficient VL Definition and Model Manipulation
Proc. IEEE Symposium on Visual Languages and Human-Centric 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 meta-modeling approach used to define the Unified Modeling Language (UML), and the graph transformation approach are very popular. Especially the combination of both, using meta-modeling 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.


Detecting Structural Refactoring Conflicts Using Critical Pair Analysis
Electr. Notes Theor. Comput. Sci. 127(3): 113-128 (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.



Generation of visual editors as eclipse plug-ins
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 well-defined 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 domain-specific solutions. In this contribution we present a general approach for defining visual languages and for generating language-specific 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 plug-in capabilities on the one hand, and formal graph transformation techniques on the other hand. More precisely, we present an Eclipse plug-in generating Java code for visual modeling plug-ins which can be directly executed in the Eclipse Runtime-Workbench.


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.


Erstellung eines grafischen Editor-Plug-Ins mit Eclipse EMF und GEF
OBJEKTspektrum, 2:31–34, 2005
Abstract.  In dem Artikel wird die Generierung eines einfachen baumbasierten Eclipse Editor-Plug-Ins 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 Editor-Plug-Ins mit dem Graphical Editor Framework (GEF) erläutert.


Simulating Algebraic High-Level 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 High-Level (AHL) nets, a high-level 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.


Simulating Algebraic High-Level Nets by Parallel Attributed Graph Transformation: Long Version
Technical Report 2004-21, 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 High-Level (AHL) nets, a high-level 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.


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.


Proc. International Workshop on Graph and Model Transformation (GraMoT'05)
ENTCS, Tallinn, Estonia, September 2005. Elsevier Science.


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.


Ensuring structural constraints in graph-based 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 meta-models 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 graph-based models being e.g. meta-models or graph transformation systems. The constraints that can be imposed by pure typing are, however, relatively weak. In the context of meta-modelling 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 pre-conditions 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 meta-modelling 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 Meta-CASE 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.


2004


Integrating Meta Modelling with Graph Transformation for Efficient Visual Language Definition and Model Manipulation
In M. Wermelinger and T. Margaria-Steffens (eds.), Proc. Fundamental Aspects of Software Engineering 2004, volume 2984. Springer LNCS, 2004.


Termination of High-Level 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.


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.


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 Parisi-Presicce, Paolo Bottoni and Gregor Engels (eds.)
Proc. 2nd Int. Conference on Graph Transformation (ICGT'04), LNCS 3256, pages 161-177, Rome, Italy, October 2004. Springer.


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): 127-143 (2005).
Abstract.  This work discusses the state-of-the-art 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 GEF-based editor from a formal, graph-transformation based visual language specification.


Workshop on Graph-Based Tools
In Francesco Parisi-Presicce, Paolo Bottoni, and Gregor Engels (eds.)
Proc. 2nd Int. Conference on Graph Transformation (ICGT'04), LNCS 3256, pages 144-160, Rome, Italy, October 2004. Springer.


Detecting Structural Refactoring Conflicts unsing Critical Pair Analysis
In Reiko Heckel and Tom Mens (eds.)
Proc. Workshop on Software Evolution through Transformations: Model-based vs. Implementation-level Solutions (SETra'04), Satellite Event of ICGT'04), Rome, Italy, October 2004. ENTCS.


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


2003


Node Type Inheritance Concepts for Typed Graph Transformation
Technical Report 2003-19, Technical University Berlin, Dept. of Computer Science, November 2003
ISSN 1436-9915


In T. Margaria (ed.), Proc. Tool Exihibition at "Formal Methods 2003", Pisa, Italy, September 2003.


2002 and before


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, Parisi-Presicce und Taentzer.


  • Tom Mens, Andy Schürr and Gabriele Taentzer (eds.):
    Graph-Based Tools (GraBaTs'02)

Volume 72 of Electronic Notes in Theoretical Computer Science (ENTCS)
Abstract.  Graphs are well-known, well-understood, 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 graph-based tool development, bring together developers of graph-based tools in different application fields and to encourage new tool development cooperations.


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.


Confluence of Typed Attributed Graph Transformation Systems
Andrea Corradini, Hartmut Ehrig, Hans-Jö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.


Detection of Conflicting Functional Requirements in a Use Case-Driven Approach
Proc. of the 24th Int. Conference on Software Engineering 2002, Orlando, USA, IEEE Computer Society
Abstract.  In object-oriented 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 object-based 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.


Towards Automatic Translation of UML Models into Semantic Domains
Applied Graph Transformation (AGT`02), satellite event of ETAPS'02, Grenoble, 2002
Hans-Jö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 view-oriented 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.


Working on OCL with Graph Transformation
Applied Graph Transformation (AGT`02), satellite event of ETAPS'02, Grenoble, 2002
Hans-Jö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 graph-transformation 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 graph-transformation rules.


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.


Semantics of Distributed System Specifications based on Graph Transformation
presented at GI-Jahrestagung 2000, Workshop "Rigorose Entwicklung software-intensiver 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.


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 graph-based 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.


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.


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.


A Visual Modeling Technique for Controlling Graph Transformation
Proc. of Satellite Workshops of 27th Int. Colloquium on Automata, Languages, and Programming, Carleton Scientifc, 2000


ViewPoint-Oriented 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ße-Rhode, Francesco Parisi-Presicce, 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.


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 double-pushout 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.


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.


Dynamic Accomodation of Change: Automated Architecture Configuration of Distributed Systems
Automated Software Engineering'99, Cocoa Beach, Florida, USA, 1999, IEEE Computer Society


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 multi-dimensional representations which have to be coded into one-dimensional strings otherwise. Furthermore, graph transformation as visual formalism is used as a basis for a certain kind of rule-based 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. Context-free as well as different kinds of context-sensitive languages are considered in this chapter. Based on these concepts, two VL environment generating tools and languages---DiaGen and GenGEd---are presented that comprise generators for visual editors and parsers based on syntax definition by graph transformation. Graph transformation languages form a kind of very high-level 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.


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 if-then-programming 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 object-oriented 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.


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.


ViewPoint-oriented 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 Object-Oriented Modeling Techniques
in Proc. of Technology of Object-Oriented Languages and Systems (TOOLS'99), IEEE, Nancy, France, 1999.


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


Visual Design of Distributed Systems by Graph Transformation,
in Proc. of the Int. Workshop on Communication-Based Systems, Oct. 1998, TU Berlin, Germany, Techn. Report 98-15


How to Integrate Graph Transformation with an Object-Oriented Language,
in Proc. 6. Int. Workshop on Theory and Application of Graph Transformation (TAGT'98), Nov. 1998, Paderborn, Germany


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 n-sorted 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 High-Level Replacement Systems
in TCS, Vol. 186, 1997
Abstract.  High-level replacement systems are an axiomatic categorical framework based on double-pushouts 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 high-level replacement systems are introduced to formalize parallel rewriting of these high-level 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 high-level 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 window-based graph editor and movement of objects in configuration spaces are presented as examples of parallel high-level replacement systems.


  • Gabriele Taentzer and Manuel Koch:
    Distributing Attributed Graph Transformation
    In First TMR GETGRATS Workshop, Bordeaux, October 1997


A Combined Reference Model- and View-Based Approach to System Specification,
International Journal of Engineering and Knowledge Engineering, Vol.7 No.4 (1997), pp. 457-477, World Scientific Publishing Company
Abstract.  The idea of a combined reference model- and view-based 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 well-defined 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 well-known example of a banking system.


A View-Oriented 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 view-based 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 well-defined 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 well-known example of a banking system.


Modeling Dynamic Distributed Object Structures by Graph Transformation
in on-line magazine Object Currents, vol.1, no. 12, 1996
Abstract.  Object-oriented 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 rule-based 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, Hans-Jö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), 1-54
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 rule-based 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 rule-centered language GRACE, currently under development, that permits systematic and structured specification and programming based on graph transformation.


Computing by Graph Transformation. A Survey and Annotated Bibliography
Technical Report, TU Berlin, No. 96-21
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)


Computing by Graph Transformation. Final Report
Technical Report, TU Berlin, No. 96-17
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 Communication-Based 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 communication-based 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 un-bounded 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 double-pushout 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 double-pushout high-level 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 single-pushout 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.


Graph Grammars with Negative Application Conditions
in special issue of Fundamenta Informaticae, vol. 26, no.3,4, 1996
Abstract.  In each graph-grammar 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 graph-grammar 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 non-existence of nodes, edges, or certain subgraphs in the given graph as well as embedding restrictions concerning the morphisms from the left-hand 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 context-free graph grammars with application conditions with respect to their generative power.


Computing by Graph Transformation II (COMPUGRAPH II). Third Interim Report ESPRIT Basic Research Working Group No. 7183.
Technical Report No. 95-23, 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 Holl-Biniasz, 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 95-7, TU-Berlin, 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)


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 single-pushout 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.


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 well-defined 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.


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.


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 AGG-system 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 user-selected production rules and occurrences. First steps towards a graph specification of an abstract version of the AGG-system are possible by using amalgamated graph transformations. AGG-states are modelled by graphs whereas AGG-operations are described by amalgamated graph transformations combining parallel and sequential rewriting of graphs

 

Zuletzt aktualisiert: 28.08.2017 · Barbara Dinklage

 
 
 
Fb. 12 - Mathematik und Informatik

Fb. 12 - Mathematik und Informatik, Hans-Meerwein-Straße 6, D-35032 Marburg
Tel. +49 6421/28-21514, Fax +49 6421/28-25466, E-Mail: dekanatfb12@mathematik.uni-marburg.de

URL dieser Seite: https://www.uni-marburg.de/fb12/arbeitsgruppen/swt/forschung/publications

Impressum | Datenschutz