In model-driven design, the structure of software is commonly specified by meta-models like uml class diagrams. In this paper we study how graph grammars can be used for this purpose, using statecharts as an example. We extend context-free hyperedge-replacement—which is not powerful enough for this application—so that rules may not only access the nodes attached to the variable on their left-hand side, but also nodes elsewhere in the graph. Although the resulting notion of contextual hyperedge replacement preserves many properties of the context-free case, it has considerably more generative power—enough to specify software models that cannot be specified by class diagrams.
The transformation judge is a novel system for the automatic evaluation and comparison of graph and model transformations that have been submitted as solutions for common transformation tasks such as those accepted as case studies for the transformation tool contest. The most important feature of this system is the correctness check that is done by black-box-testing. But also performance data and other information about the solutions are collected. So, for academic as well as industrial users of transformation tools, the judge could be a good starting point for choosing a particular transformation tool for their respective task, since they can easily explore and compare different solutions for similar tasks. In this demonstration we show the most important use cases of the judge, i.e., uploading of cases and corresponding solutions as well as the automatic evaluation and comparison of solutions.
In model driven engineering (MDE) model-to-model transformations play an important role. Nowadays, many model transformation languages for different purposes and with different formal foundations have emerged. In this paper, we present a case study that compares the Atlas Transformation Language (ATL) with Story Driven Modeling (SDM) by focusing on a complex transformation in the security domain. Additionally, we highlight the differences and shortcomings revealed by this case study and propose concepts that are missing in both languages.
Editing environments which feature animated illustrations of model changes facilitate and simplify the comprehension of dynamic systems. Graphs are well suited for representing static models and systems, and graph transformations are the obvious choice for implementing model changes and dynamic aspects. In previous work, we have devised the Animation Modeling Language (AML) as a modeling approach on a higher level. However, AML-based specification could not yet be translated into an implementation automatically. This paper presents a language extension called AML/GT and outlines how AML/GT models can be translated into graph transformation rules automatically and also provides some implementation details.
Managing complex business services on top of IT solutions is much more then managing solely the IT infrastructure beneath. Business services management requires the management of all resources and implementation layers by knowing the business logic, and includes services relevant information from different business aspects. To achieve an effective service modeling, the analysis must include resource models, connection models, error and error propagation models in a way that the models could be maintained to ensure long term business benefits. This invited talk gives an insight of the business services modeling, a possible best practice to build such models in a complex, event based fault management environment and shows the actual outcomes of a recent project at a leading telecommunication company.
In a context where graph transformation is used to explore a space of possible solutions to a given problem, it is almost always necessary to inspect candidate solutions for relevant properties. This means that there is a need for a flexible mechanism to query not only graphs but also their evolution. In this paper we show how to use Prolog queries to analyse graph exploration. Queries can operate both on the level of individual graphs and on the level of the transformation steps, enabling a very powerful and flexible analysis method. This has been implemented in the graph-based verification tool groove. As an application of this approach, we show how it gives rise to a competitive analysis technique in the domain of feature modelling.
Self-adaptive systems autonomously adjust their behavior in order to achieve their goals despite changes in the environment and the system itself. Self-adaption is typically implemented in software and often expressed in terms of architectural reconfiguration. The graph transformation formalism is a natural way to model the architectural reconfiguration in self-adaptive systems. In this paper, we present (1) how we employ graph transformations for the specification of architectural reconfiguration and (2) how we transform graph transformations into actions of the Planning Domain Definition Language (PDDL) in order to use off-the-shelf tools for the computation of self-adaptation plans. We illustrate our approach by a self-healing process and show the results of a simulation case study.
In model-driven development, model transformations can be specified using an operational (imperative) or relational (declarative) approach. When using a relational approach, approved formal concepts are necessary to derive a conform operationalization. In general, though, it is not sure if implementations realize these formal concepts in an entirely correct way. Moreover, usually, available formal concepts neither cover every technicality, nor cover each additional optimization an implementation relies on. Consequently, conformance needs to be validated also on the implementation level. Conformance means that for each source model S and target model T related according to the relational specification, a corresponding implementation transforms S into T (and T into S in case that the specification is bidirectional). We present an automatic conformance testing approach for TGG implementations, where the Triple Graph Grammar (TGG) approach is an important representative of relational model transformation approaches. We show that the grammar character of TGGs is very convenient for the automatic generation of conformance test cases. In particular, test input models can be generated together with their expected result obtaining a complete oracle. We show how to measure test suite quality and evaluate our approach on our own TGG implementation.
Declarative model transformation languages like QVT-R and TGGs are particularly convenient because mappings between models can be specified in a rule-based way, describing how patterns in one model correspond to patterns in another. The same mapping specification can be used for different transformation and synchronization scenarios, which are important in model-based software engineering. However, even though these languages already exist for a while, they are not widely used in practice today. One reason for that is that these languages often do not provide sufficiently rich features to cope with many problems that occur in practice. We report on a complex model transformation that we have solved by TGGs. We present advanced extensions of the TGG language that we have integrated in our tool, the TGG Interpreter.
In logistics and other application areas, one faces many intractable and NP-hard problems like scheduling, routing, packing, planning, and various kinds of optimization. Many of them can nicely and correctly be modeled by means of graph transformation. But a graph transformation engine fails to run the solutions properly because it does not have any mechanisms to overcome or circumvent the intractability. In this paper, we propose to combine the graph transformation engine GrGen.NET with the SAT solver MiniSat to improve the situation. SAT solvers have proved to run efficiently in many cases in the area of chip design and verification. We want to take these positive experiences up and to use the SAT solver as a tentative experiment for assisting the graph transformation engine in finding solutions to NP-hard problems.
This paper explores how to reason locally about global properties of graph transformations, in particular properties involving transitive closure of the edge relations of the graph. We show under which conditions we can soundly reduce reasoning about all nodes in the graph to reasoning about a finite set of nodes. We then give an effective procedure to turn this reduced problem into a Boolean satisfiability problem.
In this paper, we outline our pattern-based layout approach and its integration into a diagram editor. In particular, we summarize editor features that were made possible by the approach. Each layout pattern encapsulates certain layout behavior. Several layout patterns may be applied to a diagram simultaneously, even to overlapping diagram parts. Our approach includes a control algorithm that automatically deals with such situations. To support the user in an interactive environment, it is not sufficient to apply the same layout behavior in every situation. Instead, the user also wants to select and alter the layout behavior at runtime. Our approach as well as the editor features described in this paper are specifically designed for such an environment.
Model-driven software engineering intends to increase the productivity of software engineers by replacing conventional programming with the development of executable models at a high level of abstraction. It is claimed that graph transformation rules contribute towards this goal since they provide a declarative, usually graphical specification of complex model transformations. Frequently, graph transformation rules are organized into even more complex model transformations with the help of control structures, resulting in full-fledged support for executable behavioral models. This paper examines the added value of programmed graph transformations with the help of a case study from software configuration management. To this end, a large model is analyzed which was developed in the MOD2-SCM project over a period of several years. The model was developed in Fujaba, which provides story diagrams for programming with graph transformations. Our analysis shows that the model exhibits a strongly procedural flavor. Graph transformation rules are heavily used, but typically consist of very small patterns. Furthermore, story diagrams provide fairly low level control structures. Altogether, these findings challenge the claim that programming with graph transformations is performed at a significantly higher level of abstraction than conventional programming.
Meta-modeling has become the key technology to define domain-specific modeling languages for model-driven engineering. However, these modeling languages can change quite frequently which requires the evolution of their meta-models as well as the co-evolution (or migration) of their models. In this paper, we present an approach towards meta-model model co-evolution based on graph transformation concepts that targets to consider this challenge in a formal setting. 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. We present a basic approach to automatic deduction of model migrations from meta-model evolution steps which are specified by single transformation rules. Throughout that migration process, type conformance is ensured permanently. A first implementation is given using existing technology, namely the Eclipse Modeling Framework (EMF) and the EMF model transformation tool Henshin which is based on graph transformation concepts. Our evolution approach is presented at two small evolution scenarios for Petri nets and state machines.
A graph grammar is a generative description of a graph language (a possibly infinite set of graphs). In this paper, we present a novel algorithm for inducing a graph grammar from a given set of 'positive' and 'negative' graphs. The algorithm is guaranteed to produce a grammar that can generate all of the positive and none of the negative input graphs. Driven by a heuristic specific-to-general search process, the algorithm tries to find a small grammar that generalizes beyond the positive input set. During the search, the algorithm employs a graph grammar parser to eliminate the candidate grammars that can generate at least one negative input graph. We validate our method by inducing grammars for chemical structural formulas and flowcharts and thereby show its potential applicability to chemical engineering and visual programming.
Metamodelling is one of the pillars of model-driven engineering, used for language engineering and domain modelling. Even though metamodelling is traditionally based on a two-level approach, several researchers have pointed out limitations of this solution and proposed an alternative deep (also called multi-level) approach to obtain simpler system descriptions. However, deep metamodelling currently lacks a formalisation that can be used to explain fundamental concepts such as deep characterisation through potency and double linguistic/ontological typing. This paper provides different semantics for such fundamental concepts based on graph transformation and the Diagram Predicate Framework.
The integrated development environment AGG supports the specification of algebraic graph transformation systems based on attributed, typed graphs with node type inheritance, graph rules with application conditions, and graph constraints. It offers several analysis techniques for graph transformation systems including graph parsing, consistency checking of graphs as well as conflict and dependency detection in transformations by critical pair analysis of graph rules, an important instrument to support the confluence check of graph transformation systems. AGG 2.0 includes various new features added over the past two years. It supports the specification of complex control structures for rule application comprising the definition of control and object flow for rule sequences and nested application conditions. Furthermore, new possibilities for constructing rules from existing ones (e.g., inverse, minimal, amalgamated, and concurrent rules) and for more flexible usability of critical pair analyses have been realized.
Drools is the leading Java based Open Source rule engine. It is a hybrid chaining engine meaning it can react to changes in data and also provides advanced query capabilities. Drools provides built in temporal reasoning for complex event processing and is fully integrated with the jBPM project for BPMN2 based workflow. Ongoing research includes (but is not limited) to planning, ontological reasoning (semantic web), imperfect reasoning, truth maintenance and distributed collaboration through intelligent agents. This talk will provide an introduction into Drools what it is and how it works. We will explain the concepts of forward and backward chaining within the context of Drools as well as exploring the rule engine syntax and how it has been extended for temporal reasoning for complex event processing.
Model-Driven Engineering promotes models as the principal artefacts of the development, hence model transformation techniques – like graph transformation – become key enablers for this development paradigm. In order to increase the adoption of Model-Driven Engineering in industrial practice, techniques aimed at raising the quality and productivity in model transformation development are needed.
Non-destructive and quantitative analysis and screening of plant phenotypes throughout plants' lifecycles is essential to enable greater efficiency in crop breeding and to optimize decision making in crop management. In this contribution we propose graph grammars within a sensor-based system approach to the automated 3D reconstruction and semantic annotation of plant architectures. The plant architectures in turn will serve for reliable plant phenotyping. More specifically, we propose to employ Relational Growth Grammars to derive semantically annotated 3D reconstruction hypotheses of plant architectures from 3D sensor data, i.e., laser range measurements. Furthermore, we suggest deriving optimal reconstruction hypotheses by embedding the graph grammar-based data interpretation within a sophisticated probabilistic optimization framework, namely a Reversible Jump Markov Chain Monte Carlo sampling. This paper presents the design of the overall system framework with the graph grammar-based data interpretation as the central component. Furthermore, we present first system improvements and experimental results achieved in the application domain of grapevine breeding.
