DOCSLIB.ORG

Type Inference in Flexible Model-Driven Engineering

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Type Inference in Flexible Model-Driven Engineering Type Inference in Flexible Model-Driven Engineering ATHANASIOS ZOLOTAS DOCTOR OF ENGINEERING UNIVERSITY OF YORK COMPUTER SCIENCE September 2016 Abstract Model-driven Engineering (MDE) is an approach to software development that promises increased productivity and product quality. Domain models that conform to metamodels, both of which are the core artefacts in MDE approaches, are ma- nipulated to perform different development processes using specific MDE tools. However, domain experts, who have detailed domain knowledge, typically lack the technical expertise to transfer this knowledge using MDE tools. Flexible or bottom-up Model-driven Engineering is an emerging approach to domain and sys- tems modelling that tackles this challenge by promoting the use of simple drawing tools to increase the involvement of domain experts in MDE processes. In this ap- proach, no metamodel is created upfront but instead the process starts with the definition of example models that will be used to infer a draft metamodel. When complete knowledge of the domain is acquired, a final metamodel is devised and a transition to traditional MDE approaches is possible. However, the lack of a meta- model that encodes the semantics of conforming models and of tools that impose these semantics bears some drawbacks, among others that of having models with nodes that are unintentionally left untyped. In this thesis we propose the use of approaches that use algorithms from three different research areas, that of classifi- cation algorithms, constraint programming and graph similarity to help with the type inference of such untyped nodes. We perform an evaluation of the proposed approaches in a number of randomly generated example models from 10 differ- ent domains with results suggesting that the approaches could be used for type inference both in an automatic or a semi-automatic style. 3 For my parents Despoina and Michalis Contents Abstract 3 Dedication 5 Table of Contents 7 List of Figures 11 List of Tables 15 Listings 17 List of Algorithms 19 Acknowledgements 21 Declaration 23 1. Introduction 25 1.1. Motivation and Background . 25 1.1.1. Bottom-up MDE . 26 1.2. Hypothesis and Objectives . 28 1.2.1. Thesis Objectives . 29 1.3. Research Contributions . 29 1.4. Thesis Structure . 30 2. Literature Review 33 2.1. Model-Driven Engineering . 33 2.1.1. MDE Principles and Tools . 34 2.1.2. Strengths and Weaknesses of MDE . 43 2.2. Bottom-up MDE . 44 2.2.1. Muddles . 45 2.2.2. metaBUP . 49 2.2.3. Flexisketch . 52 7 Contents 2.2.4. Other . 54 2.3. Partial Models . 56 2.4. Metamodel and Type Inference . 57 2.4.1. MetaBUP . 57 2.4.2. Flexisketch . 58 2.4.3. MLCBD . 58 2.4.4. Process Development Environment (PDE) . 59 2.4.5. Metamodel Recovery System (MARS) . 60 2.5. Summary and Critique of Flexible MDE approaches . 61 2.6. Classification Algorithms . 63 2.6.1. Classification and Regression Trees (CART) . 63 2.6.2. Random Forests (RF) . 64 2.6.3. Support Vector Machines (SVM) . 65 2.6.4. Artificial Neural Networks (ANN) . 65 2.7. Constraint Logic Programming . 66 2.7.1. Logic Programming Tools & Distributions . 69 2.7.2. Combining MDE with Logic Programming . 69 2.8. Graph Similarity . 70 2.8.1. Similarity Flooding . 70 2.8.2. Using Similarity Measurements in MDE . 71 2.9. Chapter Summary . 74 3. Type Inference using Classification Algorithms 77 3.1. Introduction . 77 3.2. Type Inference . 78 3.3. Feature Signatures . 79 3.3.1. Features Based on the Semantics . 80 3.3.2. Features Based on Concrete Syntax . 83 3.3.3. Extending Muddles . 84 3.4. Training and Classification . 85 3.5. Experimental Evaluation . 86 3.5.1. Experiment for Features Based on Semantics . 86 3.5.2. Results and Discussion . 91 3.5.3. Experiment for Concrete Syntax Features . 110 3.5.4. Results and Discussion . 112 3.6. Limitations . 120 3.7. Chapter Summary . 121 4. Type Inference using Constraint Programming 123 4.1. Introduction . 123 4.2. Type Inference . 125 8 Contents 4.3. The Constraint Satisfaction Problem . 126 4.3.1. CSP Formalisation . 126 4.3.2. Model and Metamodel to CSP Transformation . 131 4.4. Experimental Evaluation . 134 4.4.1. Experiment . 135 4.4.2. Results & Discussion . 137 4.5. Limitations . 150 4.6. Chapter Summary . 152 5. Type Inference using Graph Similarity 153 5.1. Introduction . 153 5.2. Type Inference Using String Similarity . 154 5.3. Graph Configuration . 156 5.3.1. Flattened Configuration . 157 5.4. Similarity Flooding . 159 5.5. Experimental Evaluation . 162 5.5.1. Experiment . 163 5.5.2. Results and Discussion . 168 5.6. Limitations . 176 5.7. Chapter Summary . 177 6. Conclusions 179 6.1. Thesis Contributions . 180 6.2. Future Work . 184 6.3. Closing Remarks . 187 Appendices 189 A. Metamodels 191 Bibliography 201 9 List of Figures 1.1. Stages of a typical flexible MDE approach. 27 1.2. Overview of the research project. 30 2.1. The relationships between a model with its metamodel and the do- main it represents (adapted from [1]). 34 2.2. The four layers of metamodelling infrastructures (adapted from [2] and [3]). 36 2.3. An example of a metamodel. 37 2.4. An example of a model that conforms to the metamodel of Figure 2.3. 38 2.5. An example of a model-to-model transformation between instances of two different metamodels. 39 2.6. An example of a model-to-text transformation. 40 2.7. The architecture of the Epsilon suite . 42 2.8. An overview of the Muddles approach (based on Fig. 1 from [4]). 45 2.9. An example model diagram in yEd representing a zoo configura- tion. Shapes and colours are not bound to types but can be used by domain experts for the better presentation of the example models. 46 2.10. The Muddle metamodel. 48 2.11. An overview of the metaBUP approach (from [5]). 50 2.12. An example visual fragment (from [5]). 50 2.13. The Flexisketch approach’s three basic phases (from [6]). 53 2.14. The Flexisketch Android application. 54 2.15. String representation of sketches in the Coyette et al.’s approach (from [7]). 58 2.16. Concept metamodel of PDE-based languages (adapted from [8]). 60 2.17. MARS metamodel inference approach (adapted from [9]). 61 2.18. An example of a decision tree in CART (from [10]). 64 2.19. A map for colouring. 68 2.20. An overview of the similarity flooding approach. 71 2.21. An example metamodel (adapted from [11]). 72 11 List of Figures 2.22. The directed graph of the metamodel shown in Figure 2.21 using the minimal configuration (adapted from [11]). 72 2.23. An overview of Grammel et al.’ approach [12] to trace link genera- tion (adapted from [12]). 73 2.24. An example of how a metamodel is translated to an E-Graph in Grammel et al. [12] model matching approach. 74 3.1. An overview of the proposed approach to type inference using clas- sification algorithms. 79 3.2. An example model of a zoo configuration. 80 3.3. Colours and shapes are used to define semantics on graphical models. 83 3.4. The muddles extension for type inference using concrete syntax prop- erties. 84 3.5. Example decision tree for the features based on semantics. F1 repre- sents the number of attributes of a node and F2 the number of unique incoming references. 85 3.6. The experimentation process using the features based on semantics. 87 3.7. Accuracy for different sampling rates and number of trees (“Nor- mal”, Random Forests). 101 3.8. Accuracy for different sampling rates and number of trees (“Sparse”, Random Forests). 102 3.9. A metamodel from which instances of “Children” nodes may never be instantiated if the random model generator forces optional com- position relationships to be instantiated less frequently (“Sparse” sce- nario). 104 3.10. Variables importance of features based on semantics. F1 represents the number of attributes, F2 and F3 represent the number of unique incoming and outgoing references respectively and F4 and F5 the number of unique children and parents respectively. 106 3.11. The concrete features experimentation process. ..
Load more

Recommended publications
  • The Model Transformation Language of the VIATRA2 Framework
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Elsevier - Publisher Connector Science of Computer Programming 68 (2007) 214–234 www.elsevier.com/locate/scico The model transformation language of the VIATRA2 framework Daniel´ Varro´ ∗, Andras´ Balogh Budapest University of Technology and Economics, Department of Measurement and Information Systems, H-1117, Magyar tudosok krt. 2., Budapest, Hungary OptXware Research and Development LLC, Budapest, Hungary Received 15 August 2006; received in revised form 17 April 2007; accepted 14 May 2007 Available online 5 July 2007 Abstract We present the model transformation language of the VIATRA2 framework, which provides a rule- and pattern-based transformation language for manipulating graph models by combining graph transformation and abstract state machines into a single specification paradigm. This language offers advanced constructs for querying (e.g. recursive graph patterns) and manipulating models (e.g. generic transformation and meta-transformation rules) in unidirectional model transformations frequently used in formal model analysis to carry out powerful abstractions. c 2007 Elsevier B.V. All rights reserved. Keywords: Model transformation; Graph transformation; Abstract state machines 1. Introduction The crucial role of model transformation (MT) languages and tools for the overall success of model-driven system development has been revealed in many surveys and papers during the recent years. To provide a standardized support for capturing queries, views and transformations between modeling languages defined by their standard MOF metamodels, the Object Management Group (OMG) has recently issued the QVT standard. QVT provides an intuitive, pattern-based, bidirectional model transformation language, which is especially useful for synchronization kind of transformations between semantically equivalent modeling languages.
    [Show full text]
  • Lessons Learned from Building Model-Driven Development Tools
    Noname manuscript No. (will be inserted by the editor) Lessons Learned from Building Model-Driven Development Tools Richard F. Paige1 and D´anielVarr´o2 Department of Computer Science, University of York, UK. e-mail: [email protected] Department of Measurement and Information Systems Budapest University of Technology and Economics, Hungary. e-mail: [email protected] The date of receipt and acceptance will be inserted by the editor Abstract Tools to support modelling in system and of MDD tools. The principles will be distilled from an software engineering are widespread, and have reached analysis of the development of two MDD tools that are a degree of maturity where their use and availability used in practice: VIATRA and Epsilon. These tools are are accepted. Tools to support Model-Driven Develop- used in industry, on real projects, and have developed ment (MDD) { where models are manipulated and man- in very different ways. Arguably, some of the lessons aged throughout the system/software engineering lifecy- learned from the development of these tools can inform cle { have, over the last ten years, seen much research the development of new MDD tools, and can also be and development attention. Over the last ten years, we used to support the evolution of existing tools. Our ob- have had significant experience in the design, develop- jective is not to propose the \ideal" MDD tool; such a ment and deployment of MDD tools in practical settings. tool is unlikely to exist. However, the principles under- In this paper, we distill some of the important lessons pinning the development of MDD tools that are widely we have learned in developing and deploying two MDD used in practice can help in assessing existing tools, and tools: Epsilon and VIATRA.
    [Show full text]
  • Model-Driven Engineering, the System Under Development Is Described and Analyzed Using Models
    X perf =1.00 X loss =0.01 SDSoftware Design and Quality A Declarative Language for Bidirectional Model Consistency Master’s Thesis of Dominik Werle at the Department of Informatics Institute for Program Structures and Data Organization (IPD) Reviewer: Prof. Dr. Ralf H. Reussner Second reviewer: Jun.-Prof. Dr.-Ing. Anne Koziolek Advisor: Dipl.-Inform. Max E. Kramer Second advisor: M.Sc. Michael Langhammer 09. October 2015 – 08. April 2016 Karlsruher Institut für Technologie Fakultät für Informatik Postfach 6980 76128 Karlsruhe I declare that I have developed and written the enclosed thesis completely by myself, and have not used sources or means without declaration in the text. Karlsruhe, 08. April 2016 .................................... (Dominik Werle) Abstract In model-driven engineering, the system under development is described and analyzed using models. Dierent models provide dierent abstractions of the system for dierent purposes. If multiple modeling languages are used, their models can contain overlapping informa- tion about the system. Then, they can become inconsistent after changes and need to be synchronized. The complexity of synchronizing models can be reduced by specifying consistency relationships in specialized languages and by automating the synchronization based on this specication. The languages can hide complexity that is not specic to the domain of the modeling languages, for example by deriving the operations needed for propagating changes from a model to another model for all pairs of models instead of requiring explicit specication for each pair and direction. In the course of this thesis, we designed the mapping language for specifying these consistency relationships and implemented a framework that maintains consistency based on the specication.
    [Show full text]
  • Research Report
    RZ 3621 (# 99631) 07/18/2005 Computer Science 10 pages Research Report A Systematic Approach to Designing Model Transformations Jochen M. Kuster,¨ Ksenia Ryndina and Rainer Hauser IBM Research GmbH Zurich Research Laboratory 8803 Ruschlikon¨ Switzerland {jku,ryn,rfh}@zurich.ibm.com LIMITED DISTRIBUTION NOTICE This report will be distributed outside of IBM up to one year after the IBM publication date. Some reports are available at http://domino.watson.ibm.com/library/Cyberdig.nsf/home. Research IBM Almaden · Austin · Beijing · Delhi · Haifa · T.J. Watson · Tokyo · Zurich A Systematic Approach to Designing Model Transformations Jochen M. Kuster¨ , Ksenia Ryndina and Rainer Hauser IBM Zurich Research Laboratory 8803 R¨uschlikon Switzerland jku,ryn,rfh ¡ @zurich.ibm.com Abstract forming them into a formal language [9]. Currently, a great deal of research is focused on the expression of model transformation Design and implementation of model transformations is one designs and appropriate tool support for model transformation de- key prerequisite for the vision of model driven development to be- velopers. This has led to the Query/Views/Transformation (QVT) come true. However, model transformations are quite different proposal by the Object Management Group (OMG) [21], which from other software artifacts since a model transformation design aims to provide a standardized framework for model transforma- typically consists of a set of transformation rules instead of object- tion development. oriented models such as class diagrams and statecharts. There- fore traditional software engineering approaches are not directly Many existing model transformation approaches favor that applicable for the development of model transformations. Never- transformations are captured in a rule-based way by a set of trans- theless, in the line of existing software engineering practice, model formation rules (see VIATRA [5], GReAT [13], UMLX [26], transformations must be developed in a systematic way in order to BOTL [4] and work by Milicev [17]).
    [Show full text]
  • Expressive and Efficient Model Transformation with an Internal DSL
    Expressive and Efficient Model Transformation with an Internal DSL of Xtend Artur Boronat Department of Informatics, University of Leicester, UK [email protected] ABSTRACT 1 INTRODUCTION Model transformation (MT) of very large models (VLMs), with mil- Over the past decade the application of MDE technology in indus- lions of elements, is a challenging cornerstone for applying Model- try has led to the emergence of very large models (VLMs), with Driven Engineering (MDE) technology in industry. Recent research millions of elements, that may need to be updated using model efforts that tackle this problem have been directed at distributing transformation (MT). This situation is characterized by important MT on the Cloud, either directly, by managing clusters explicitly, or challenges [26], starting from model persistence using XMI serial- indirectly, via external NoSQL data stores. In this paper, we draw at- ization with the Eclipse Modeling Framework (EMF) [31] to scalable tention back to improving efficiency of model transformations that approaches to apply model updates. use EMF natively and that run on non-distributed environments, An important research effort to tackle these challenges was showing that substantial performance gains can still be reaped on performed in the European project MONDO [19] by scaling out that ground. efficient model query and MT engines, such as VIATRA[3] and We present Yet Another Model Transformation Language (YAMTL), ATL/EMFTVM [46], building on Cloud technology either directly, a new internal domain-specific language (DSL) of Xtend for defin- by using distributed clusters of servers explicitly, or indirectly, by ing declarative MT, and its execution engine.
    [Show full text]
  • Formal Validation and Model Generationfor Domain-Specific
    Budapest University of Technology and Economics Faculty of Electrical Engineering and Informatics Department of Measurement and Information Systems Formal Validation and Model Generation for Domain-Specific Languages by Logic Solvers Thesis booklet Oszkár Semeráth Thesis supervisor: Prof. Dániel Varró Budapest, 2019 1. Introduction 1 Introduction 1.1 Domain-specific modeling languages My thesis is motivated by the challenges in the development of complex, safety- critical systems such as automotive, avionics or cyber-physical systems, which is characterized by a long development time and strict safety standards (like DO-178C or DO-330). Model-Based System Engineering (MBSE) is a widely used technique in those application domains [WHR14], which facilitates the use of models in different phases of design and on various levels of abstraction. Fur- thermore, MBSE promotes the use of Domain-Specific (Modeling) Languages (DSLs) to precisely capture the main features of a target domain, thus en- abling the engineers to model their solutions with the concepts of the problem domain. Additionally, advanced modeling environments can automate several development steps, with a particular emphasis on verification and validation (V&V). Thus they can significantly improve the overall productivity of the de- velopment and quality of the product. A complex industrial modeling environment supports the development of models by continuously evaluating consistency constraints to ensure that the models satisfy the design rules of the domain. There is already efficient sup- port for automatically validating constraints and design rules over large model instances of the DSL using tools like Eclipse OCL [Wil12; KPP09] or Viatra [Ber+11; Ber+10]. Modeling environments often incorporate the automated generation of various artifacts such as source code, task specific views, or doc- umentation by using code generation or model transformation techniques.
    [Show full text]
  • Efficient ATL Incremental Transformations
    Journal of Object Technology Published by AITO | Association Internationale pour les Technologies Objets http://www.jot.fm/ Efficient ATL Incremental Transformations Th´eoLe Calvara Fr´ed´ericJouaultb Fabien Chhelb Mickael Clavreulb a. LERIA, University of Angers, France b. ERIS Team, Groupe ESEO, France Abstract Incrementally executing model transformations offers several benefits such as updating target models in-place (instead of creating a new copy), as well as generally propagating changes faster (compared with complete re-execution). Active operations have been shown to of- fer performant OCL-based model transformation incrementality with use- ful properties like fine-grained change propagation, and the preservation of collection ordering. However, active operations have so far only been available as a Java library. This compels users to program at a relatively low level of abstraction, where most technical details are still present. Writing transformations at this level of abstraction is a tedious and error prone work. Using languages like Xtend alleviates some but not all issues. In order to provide active operation users with a more user-friendly front-end, we have worked on compiling ATL code to Java code using the active operations library. Our compiler can handle a significant subset of ATL, and we show that the code it generates provides similar performance to hand-written Java or Xtend code. Furthermore, this compiler also enables new possibilities like defining derived properties by leveraging the ATL refining mode. Keywords Incremental model transformation Active operations ATL. 1 Introduction Incremental model transformation execution offers many advantages over batch (i.e., non-incremental) execution, such as faster change propagation.
    [Show full text]
  • The Train Benchmark: Cross-Technology Performance Evaluation of Continuous Model Queries
    Softw Syst Model DOI 10.1007/s10270-016-0571-8 REGULAR PAPER The Train Benchmark: cross-technology performance evaluation of continuous model queries Gábor Szárnyas1,2,3 · Benedek Izsó1 · István Ráth1,4 · Dániel Varró1,2,3 Received: 30 October 2015 / Revised: 27 March 2016 / Accepted: 3 October 2016 © The Author(s) 2017. This article is published with open access at Springerlink.com Abstract In model-driven development of safety-critical tion rules is challenging for the currently available tools. systems (like automotive, avionics or railways), well- Checking well-formedness constraints can be captured by formedness of models is repeatedly validated in order to declarative queries over graph models, while model update detect design flaws as early as possible. In many indus- operations can be specified as model transformations. This trial tools, validation rules are still often implemented by paper presents a benchmark for systematically assessing the a large amount of imperative model traversal code which scalability of validating and revalidating well-formedness makes those rule implementations complicated and hard constraints over large graph models. The benchmark defines to maintain. Additionally, as models are rapidly increas- well-formedness validation scenarios in the railway domain: ing in size and complexity, efficient execution of valida- a metamodel, an instance model generator and a set of well- formedness constraints captured by queries, fault injection Communicated by Prof. Lionel Briand. and repair operations (imitating the work of systems engi- neers by model transformations). The benchmark focuses This work was partially supported by the MONDO (EU ICT-611125) project, the MTA-BME Lendület Research Group on Cyber-Physical on the performance of query evaluation, i.e.
    [Show full text]
  • Graphical Debugging of QVT Relations Using Transformation Nets
    Graphical Debugging of QVT Relations using Transformation Nets DIPLOMARBEIT zur Erlangung des akademischen Grades Diplom-Ingenieur im Rahmen des Studiums Wirtschaftsinformatik eingereicht von Patrick Zwickl Matrikelnummer 0525849 an der Fakultat¨ fur¨ Informatik der Technischen Universitat¨ Wien Betreuung: Betreuerin: Univ.-Prof. Mag. DI Dr. Gerti Kappel Mitwirkung: DI(FH) Johannes Schonb¨ ock¨ Wien, 07.12.2009 (Unterschrift Verfasser) (Unterschrift Betreuer) Technische Universitat¨ Wien A-1040 Wien Karlsplatz 13 Tel. +43/(0)1/58801-0 http://www.tuwien.ac.at Erkl¨arung zur Verfassung der Arbeit Patrick Zwickl, Gr¨ohrmuhlgasse¨ 36E, 2700 Wiener Neustadt Hiermit erkl¨are ich, dass ich diese Arbeit selbst¨andig verfasst habe, dass ich die verwendeten Quellen und Hilfsmittel vollst¨andig angegeben habe und dass ich die Stellen der Arbeit einschließlich Tabellen, Karten und Abbildungen, die anderen Werken oder dem Internet im Wortlaut oder dem Sinn nach entnommen sind, auf jeden Fall unter Angabe der Quelle als Entlehnung kenntlich gemacht habe. Wien, 7. Dezember 2009 Patrick Zwickl i ii Danksagung Im Zuge meines Studium wurde ich von vielen Menschen, als Kommilitonen, Lehrende, Betreuuer, Freunde, Familie etc., begleitet. Dabei war es mir m¨oglich Unterstutzungen¨ auf verschiedensten Ebenen zu erhalten oder in einer guten Zusammenarbeit respektable Ergebnisse zu erzielen. Aufgrund der gr¨oßeren Zahl an Begleitern, m¨ochte ich mich in der Danksagung im Besonderen auf jene Un- terstutzer¨ beschr¨anken, die in einem uberdurchschnittlichen¨ Zusammenhang mit dieser Diplomarbeit stehen. Ich m¨ochte mich sehr herzlich fur¨ die engagierte Hilfe, Leitung und Supervision bei meinen Betreuuern O.Univ.-Prof. Mag. DI Dr. Gerti Kappel und Univ.- Ass. Mag. Dr.
    [Show full text]
  • Metamodeling and Model Transformations in Modeling and Simulation
    Proceedings of the 2011 Winter Simulation Conference S. Jain, R. R. Creasey, J. Himmelspach, K. P. White, and M. Fu, eds. METAMODELING AND MODEL TRANSFORMATIONS IN MODELING AND SIMULATION Deniz Cetinkaya Alexander Verbraeck Systems Engineering Group, Faculty of Technology, Policy and Management Delft University of Technology Jaffalaan 5, 2628BX, Delft, THE NETHERLANDS ABSTRACT Metamodeling and model transformations are the key concepts in Model Driven Development (MDD) approaches as they provide a mechanism for automated development of well structured and maintainable systems. However, neither defining a metamodel nor developing a model transformation is an easy task. In this paper, we provide an overview of metamodeling and model transformations in MDD and discuss about the use of a MDD approach in Modeling and Simulation (M&S). In order to support the development of successful model transformations, we define the criteria for the evaluation of model transformations. 1 INTRODUCTION In Model Driven Development (MDD), models are the primary artifacts of the development process and they represent the system on different levels of abstraction. A model is an abstract representation of a system defined in a modeling language, where a modeling language is a means of expressing systems in a formal and precise way by using diagrams, rules, symbols, signs, letters, numerals, etc.. Metamodeling is widely accepted as a superior way to describe models in MDD context. A metamodel is a definition of a modeling language, which should be defined in a modeling language as well (Sprinkle et al. 2007). A sound metamodel describes models in a well-defined manner. Model transformations are used to create new models based on the existing information throughout the MDD process (Sendall and Kozaczynski 2003).
    [Show full text]
  • Matters of Model Transformation
    Matters of Model Transformation Eugene Syriani January 2, 2009 Abstract Model transformation is at the center of current model-driven engineering research. The current state-of-the- art includes a plethora of techniques and tools for model transformations. One of the most popular approaches is based on graph rewriting. In this report, the most important foundations of graph transformation as well as some of the most efficient techniques for applying these transformations are reviewed. A comparison of the implementation of controlled or programmed graph transformation in various tools is also given. More declarative specifications of graph transformations are discussed. Finally, scalability of model transformation with non graph-based approaches is investigated. The goal of this literature review is to identify open problems and to serve as a starting point for new research. 1 Overview In model-driven engineering, models and transformations are first-class entities. A model represents an abstrac- tion of a real system, focusing on some of its properties. Models are used to specify, simulate, test, verify, and generate code for applications. In language engineering terms, a model conforms to a meta-model. A meta-model defines the abstract syntax and static semantics of a set (possibly infinite) of models. A model is thus typed by its meta-model that specifies its permissible syntax, often in the form of constraints. A common representation of meta-models uses the Unified Modelling Language (UML) Class Diagram notation [1] with Object Constraint Language (OCL) constraints [2]. Model transformation transforms a source model into a target model1, each conforming to their respective meta-model.
    [Show full text]
  • Model Transformation by Graph Transformation: a Comparative Study
    Model Transformation by Graph Transformation: A Comparative Study Gabriele Taentzer1, Karsten Ehrig1, Esther Guerra2, Juan de Lara3, Laszlo Lengyel4, Tihamer Levendovszky4, Ulrike Prange1, Daniel Varro4, and Szilvia Varro-Gyapay4 1 Technische Universit¨atBerlin, Germany {karstene,gabi,ullip}@cs.tu-berlin.de 2 Universidad Carlos III de Madrid, Spain [email protected] 3 Universidad Autonoma de Madrid, Spain [email protected] 4 Budapest University of Technology and Economics, Hungary {varro,gyapay}@mit.bme.hu {lengyel,tihamer}@aut.bme.hu 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 com- mon 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 transforma- tions 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. 1 Introduction Raising the abstraction level from textual programming languages to visual mod- eling languages, model transformation techniques and tools have become more focused recently. Model transformation problems can be formulated as graph transformation problems, thus, a variety of tools choose this technique as the underlying mechanism for the transformation engine. This paper aims at com- paring four approaches to model transformation that apply graph transforma- tion techniques for model transformation. These can be characterized by their tool support. The presented tools are AGG [1], AToM3 [15], VIATRA2 [25] and VMTS [26] [16].
    [Show full text]