Erhan Leblebici

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.

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.

Multi-amalgamated Triple Graph Grammars

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.

A Static Analysis of Non-confluent Triple Graph Grammars for Efficient Model Transformation

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.

Tool Support for Multi-amalgamated Triple Graph Grammars

We present in this paper our tool support with eMoflon (www.emoflon.org) to incorporate the concept of multi-amalgamation into Triple Graph Grammars (TGGs). Multi-amalgamation provides a mechanism similar to a foreach loop for graph transformation rules by consolidating multiple applications of rules depending on how many rule applications are available at transformation time. TGGs are a well-known technique used to specify bidirectional model transformation, where consistency is described via triple rules that build up source, target, and correspondence models simultaneously. Combining both techniques in eMoflon yields a TGG implementation that can handle bidirectional consistency relations between source and target elements, whose number is unknown at design time and can only be determined at transformation time. Our goal with this extension is to tackle transformation scenarios that are currently beyond the capabilities of classical TGGs.

Description Languages for Consistency Management Scenarios Based on Examples from the Industry Automation Domain

To cope with the increasing complexity of developing and maintaining modern (software) systems, multiple abstractions (models) of the same system can be established and used to allow different domain experts to collaborate and contribute their respective expertise. This divide-and-conquer, model-based approach requires, however, support for a concurrent engineering process, i.e., providing a means of checking, restoring, and ensuring the consistency of all involved and concurrently maintained models. The task of providing such support is often referred to as consistency management. Although there exist various approaches to consistency management and numerous (industrial) case studies described in the literature on bidirectional transformations (bx), there is currently no uniform description of diverse but related industrial applications of model synchronisation and other forms of consistency management. This makes it challenging to detect similarities and differences related to requirements, constraints, applied techniques and tools. It is thus difficult to compare and transfer knowledge gained from (successful) projects to other bx approaches or even other bx tools for the same general approach. In this paper, therefore, we propose a description language for envisioned scenarios in the problem domain of consistency management, as well as a complementary description language for solution strategies in terms of method fragments and method patterns in the solution domain of Model-Driven Engineering (MDE). Our work is inspired by previous research in the bx and MDE communities, and is also based on our collective experience from over ten years of investigating a series of application scenarios in the industry automation section together with Siemens AG as an industrial partner. [Abridged due to arXiv]

Leveraging Incremental Pattern Matching Techniques for Model Synchronisation

Triple Graph Grammars (TGGs) are a declarative, rule-based approach to model synchronisation with numerous implementations. TGG-based approaches derive typically a set of operational graph transformations from direction-agnostic TGG rules to realise model synchronisation. In addition to these derived graph transformations, however, further runtime analyses are required to calculate the consequences of model changes in a synchronisation run. This part of TGG-based synchronisation is currently manually implemented, which not only increases implementation and tool maintenance effort, but also requires tool or at least approach-specific proofs for correctness. In this paper, therefore, we discuss how incremental graph pattern matchers can be leveraged to simplify the runtime steps of TGG-based synchronisation. We propose to outsource the task of calculating the consequences of model changes to an underlying incremental pattern matcher. As a result, a TGG-based synchroniser is reduced to a component reacting solely to appearing and disappearing matches. This abstracts high-level synchronisation goals from low-level details of handling model changes, providing a viable and unifying foundation for a new generation of TGG tools.

Multi-amalgamated triple graph grammars: Formal foundation and application to visual language translation

Visual languages (VLs) facilitate software development by not only supporting communication and abstraction, but also by generating various artifacts such as code and reports from the same high-level specification. VLs are thus often translated to other formalisms, in most cases with bidirectionality as a crucial requirement to, e.g., support re-engineering of software systems. Triple Graph Grammars (TGGs) are a rule-based language to specify consistency relations between two (visual) languages from which bidirectional translators are automatically derived. TGGs are formally founded but are also limited in expressiveness, i.e., not all types of consistency can be specified with TGGs. In particular, 1-to-n correspondence between elements depending on concrete input models cannot be described. In other words, a universal quantifier over certain parts of a TGG rule is missing to generalize consistency to arbitrary size. To overcome this, we transfer the well-known multi-amalgamation concept from algebraic graph transformation to TGGs, allowing us to mark certain parts of rules as repeated depending on the translation context. Our main contribution is to derive TGG-based translators that comply with this extension. Furthermore, we identify bad smells on the usage of multi-amalgamation in TGGs, prove that multi-amalgamation increases the expressiveness of TGGs, and evaluate our tool support

Virtual Network Embedding: Reducing the Search Space by Model Transformation Techniques

Virtualization is a promising technology to enhance the scalability and utilization of data centers for managing, developing, and operating network functions. Furthermore, it allows to flexibly place and execute virtual networks and machines on physical hardware. The problem of mapping a virtual network to physical resources, however, is known to be \(\mathcal {NP}\)-hard and is often tackled by optimization techniques, e.g., by (ILP). On the one hand, highly tailored approaches based on heuristics significantly reduce the search space of the problem for specific environments and constraints, which, however, are difficult to transfer to other scenarios. On the other hand, ILP-based solutions are highly customizable and correct by construction with a huge search space. To mitigate search space problems while still guaranteeing correctness, we propose a combination of model transformation and ILP techniques. This combination is highly customizable and extensible in order to support multiple network domains, environments, and constraints allowing for rapid prototyping in different settings of virtualization tasks. Our experimental evaluation, finally, confirms that model transformation reduces the size of the optimization problem significantly and consequently the required runtime while still retaining the quality of mappings.

Controlling the Attack Surface of Object-Oriented Refactorings

Refactorings constitute an effective means to improve quality and maintainability of evolving object-oriented programs. Search-based techniques have shown promising results in finding optimal sequences of behavior-preserving program transformations that (1) maximize code-quality metrics and (2) minimize the number of changes. However, the impact of refactorings on extra-functional properties like security has received little attention so far. To this end, we propose as a further objective to minimize the attack surface of programs (i.e., to maximize strictness of declared accessibility of class members). Minimizing the attack surface naturally competes with applicability of established MoveMethod refactorings for improving coupling/cohesion metrics. Our tool implementation is based on an EMF meta-model for Java-like programs and utilizes MOMoT, a search-based model-transformation framework. Our experimental results gained from a collection of real-world Java programs show the impact of attack surface minimization on design-improving refactorings by using different accessibility-control strategies. We further compare the results to those of existing refactoring tools.