Anthony Anjorin

A Survey of Triple Graph Grammar Tools

Model transformation plays a central role in Model-Driven Engineer- ing (MDE) and supporting bidirectionality is a current challenge with important applications. Triple Graph Grammars (TGGs) are a formally founded, bidirectional model transformation language shown by numerous case studies to be promising and useful in practice. TGGs have been researched for more than 15 years and multiple TGG tools are under active development. Although a common theoreti- cal foundation is shared, TGG tools differ considerably concerning expressiveness, applicability, efficiency, and the underlying translation algorithm. There currently exists neither a quantitative nor a qualitative overview and comparison of TGG tools and it is quite difficult to understand the different foci and corresponding strengths and weaknesses. Our contribution in this paper is to develop a set of criteria for com- paring TGG tools and to provide a concrete quantitative and qualitative comparison of three TGG tools.

Developing eMoflon with eMoflon

eMoflon is a Model-Driven Engineering (MDE) tool that supports rule-based unidirectional and bidirectional model transformation. eMoflon is not only being used successfully for both industrial case studies and in academic research projects, but is also consequently used to develop itself. This is known as bootstrapping and has become an important test, proof-of-concept, and success story for us. Interestingly, although MDE technologies are inherently self-descriptive and higher-order, very few actively developed MDE tools are bootstrapped. In this paper, we (i) report on the current state and focus of eMoflon, (ii) share our experience with bootstrapping in an MDE context, and (iii) provide a scalability analysis of a core component in eMoflon implemented as both a unidirectional and bidirectional model transformation with eMoflon.

Efficient model synchronization with precedence triple graph grammars

Triple Graph Grammars (TGGs) are a rule-based technique with a formal background for specifying bidirectional and incremental model transformation. In practical scenarios, unidirectional rules for incremental forward and backward transformation are automatically derived from the TGG rules in the specification, and the overall transformation process is governed by a control algorithm. Current incremental implementations either have a runtime complexity that depends on the size of related models and not on the number of changes and their affected elements, or do not pursue formalization to give reliable predictions regarding the expected results. In this paper, a novel incremental model synchronization algorithm for TGGs is introduced, which employs a static analysis of TGG specifications to efficiently determine the range of influence of model changes, while retaining all formal properties.

A Comparison of Incremental Triple Graph Grammar Tools

Triple Graph Grammars (TGGs) are a graph-based and visual technique for specifying bidirectional model transformation. TGGs can be used to transform models from scratch (in the batch mode), but the real potential of TGGs lies in propagating updates incrementally. Existing TGG tools differ considerably in their incremental mode concerning underlying algorithms, user-oriented aspects, incremental update capabilities, and formal properties. Indeed, the different foci, strengths, and weaknesses of current TGG tools in the incremental mode are difficult to discern, especially for non-developers. In this paper, we close this gap by (i) identifying a set of criteria for a qualitative comparison of TGG tools in the incremental mode, (ii) comparing three prominent incremental TGG tools with regard to these criteria, and (iii) conducting a quantitative comparison by means of runtime measurements.

Bidirectional model transformation with precedence triple graph grammars

Triple Graph Grammars (TGGs) are a rule-based technique with a formal background for specifying bidirectional model transformation. In practical scenarios, the unidirectional rules needed for the forward and backward transformations are automatically derived from the TGG rules in the specification, and the overall transformation process is governed by a control algorithm. Current implementations either have a worst case exponential runtime complexity, based on the number of elements to be processed, or pose such strong restrictions on the class of supported TGGs that practical real-world applications become infeasible. This paper, therefore, introduces a new class of TGGs together with a control algorithm that drops a number of practice-relevant restrictions on TGG rules and still has a polynomial runtime complexity.

Modularizing Triple Graph Grammars Using Rule Refinement

Model transformation plays a central role in Model-Driven Engineering. In application scenarios such as tool integration or view specification, bidirectionality is a crucial requirement. Triple Graph Grammars (TGGs) are a formally founded, bidirectional transformation language, which has been used successfully in various case studies from different applications domains. In practice, supporting the maintainability of TGGs is a current challenge and existing modularity concepts, e.g., to avoid pattern duplication in TGG rules, are still inadequate. Existing TGG tools either provide no support at all for modularity, or provide limited support with restrictions that are often not applicable. In this paper, we present and formalize a novel modularity concept for TGGs: Rule refinement, which generalizes existing modularity concepts, solves the problem of pattern duplication, and enables concise, maintainable specifications.

Efficient Model Synchronization with View Triple Graph Grammars

Model synchronization is a crucial task in the context of Model Driven Engineering. Especially when creating and maintaining multiple suitable abstractions or views of a complex system, a bidirectional transformation is required to keep all views and the corresponding system synchronized by automatically propagating changes in both directions. Triple Graph Grammars (TGGs) are a declarative, rule-based bidirectional transformation language, which can be used to support model synchronization. In practice, most TGG tools restrict the supported class of TGGs for efficiency reasons. These restrictions are, however, seldom intuitive and are often difficult to understand and adhere to, especially for non-experts. View Triple Graph Grammars (VTGGs) are a restricted form of TGGs, which can be highly optimized for efficient view update propagation. We argue that the restrictions posed by VTGGs are explicit and intuitive for users, as they can be adequately motivated based on the main application scenarios for VTGGs. In this paper, we present for the first time a formalization of VTGGs, stating precisely the advantages and limitations of VTGGs as compared to TGGs, and backing our claims with initial runtime measurements from a practical case study.

Traceability maintenance: factors and guidelines

Traceability is an important concern for numerous software engineering activities. Establishing traceability links is a challenging and cost-intensive task, which is uneconomical without suitable strategies for maintaining high link quality. Current approaches to Traceability Management (TM), however, often make important assumptions and choices without ensuring that the consequences and implications for trace-ability maintenance are feasible and desirable in practice. In this paper, therefore, we identify a set of core factors that influence how the quality of traceability links can be maintained. For each factor, we discuss relevant challenges and provide guidelines on how best to ensure viable traceability maintenance in a practical TM approach. Our guidelines are meant to be used by tool developers and users to select the most appropriate TM approach for their needs. Our results are based on and supported by data collected from interviews conducted with: (i) 9 of our industrial and academic project partners to elicit requirements for a TM tool, and (ii) 24 software development stakeholders from 15 industrial cases to provide a broader overview of the current state of the practice on TM. To evaluate the feasibility of our guidelines, we investigate a set of existing TM approaches used in industry with respect to our guidelines.

Unification of compiled and interpreter-based pattern matching techniques

In this paper, we propose a graph pattern matching framework that produces both a standalone compiled and an interpreter-based engine as a result of a uniform development process. This process uses the same pattern specification and shares all internal data structures, and nearly all internal modules. Additionally, runtime performance measurements have been carried out on both engines with exactly the same parameter settings to assess and reveal the overhead of our interpreter-based solution.

On the Usage of TGGs for Automated Model Transformation Testing

As model transformations are fundamental to model-driven engineering, assuring their quality is a central task which can be achieved by testing with sufficiently adequate and large test suites. As the latter requirement can render manual testing prohibitively costly in practice, a high level of automation is advisable. Triple Graph Grammars (TGGs) have been shown to provide a promising solution to this challenge as not only test case generators, but also generic test oracles can be derived from them. It is, however, unclear if such generated test suites are indeed adequate and, as different strategies can be used to steer the test generation process, a systematic means of comparing and evaluating such test suites and strategies is required.