DOCSLIB.ORG

Model Transformation By-Example

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Model Transformation By-Example Ph.D. Thesis Model Transformation By-Example MTBE Conducted for the purpose of receiving the academic title ’Doktor der Sozial- und Wirtschaftswissenschaften’ Advisors o.Univ.-Prof. Dipl.-Ing. Mag. Dr. Gerti Kappel Institute of Software Technology and Interactive Systems Vienna University of Technology Ao.Univ.-Prof. Mag. Dr. Christian Huemer Institute of Software Technology and Interactive Systems Vienna University of Technology Submitted at the Vienna University of Technology Faculty of Informatics by Michael Strommer 0025232 Schliemanngasse 9/6 A-1210 Vienna Vienna, May 2008 Danksagung Diese Arbeit wäre ohne die Unterstützung und Hilfe von KollegInnen, BetreuerInnen, Fre- undInnen und Familie nicht möglich gewesen. Mein besonderer Dank gilt meinen beiden BetreuerInnen Gerti Kappel und Christian Huemer die mich bei der Wahl des Themas und der Durchführung der Dissertation unterstützt haben. Meinen Kollegen Manuel Wimmer und Horst Kargl möchte ich für die zahlreichen Diskussionen danken, die immer wieder spannende Ergebnisse geliefert haben. Manuel Wimmer möchte ich besonders für die Idee zu dem Thema dieser Dissertation danken. Meinen beiden Diplomanden Abraham und Gerald Müller gilt mein Dank für ihre Un- terstützung bei der Implementierung eines Prototyps. Natürlich möchte ich mich auch ganz besonders bei meinen Eltern Eva und Norbert Strommer sowie meinen Freunden bedanken die immer ein offenes Ohr für meine Anliegen und Probleme hatten. Und zuletzt möchte ich noch meinem Freund Jürgen Falb für seine Geduld und Hilfsbereitschaft in den letzten Jahren danken. i ii Abstract Model-Driven Engineering (MDE) is getting more and more attention as a viable alternative to the traditional code-centric software development paradigm. With its progress, several model transformation approaches and languages have been developed in the past years. Most of these approaches are metamodel-based and, therefore, require knowledge of the abstract syntax of the modeling languages, which in contrast is not necessary for defining domain models using the concrete syntax of the respective languages. Based on the by-example paradigm, we propose Model Transformation By-Example (MTBE), to cope with shortcomings of current model transformation approaches. Our ap- proach allows the user to define semantic correspondences between concrete syntax ele- ments with the help of special mapping operators. This is more user-friendly than directly specifying model transformation rules and mappings on the metamodel level. In general, the user’s knowledge about the notation of the modeling language and the meaning of mapping operators is sufficient for the definition of model transformations. The definition of mapping operators is subject to extension, which has been applied for the definition of mapping operators for the structural and the behavioral modeling domain. However, to keep things transparent and user-friendly, only a minimal set of mapping operators has been implemented. To compensate for the additional expressiveness inherent in common model transformation languages we apply reasoning algorithms on the models represented in concrete as well as in abstract syntax and on the metamodels generating adequate trans- formation code. In order to fulfill the requirements for a user-friendly application of MTBE, proper tool support and methods to guide the mapping and model transformation generation tasks are a must. Hence, a framework for MTBE was designed that builds on state-of-the-art MDE tools on the Eclipse platform, such as the Eclipse Modeling Framework (EMF), the Graphical Modeling Framework (GMF), the Atlas Transformation Language (ATL), and the Atlas Model Weaver (AMW). The decision to base our implementation on top of Eclipse and further Eclipse projects was driven by the fact, that there is a huge community we can address with our MTBE plug-in. Finally, we evaluate our approach by means of two case studies covering the structural as well as behavioral modeling language domain. iii iv Kurzfassung Die modellgetriebene Softwareentwicklung kann immer mehr als ernst zu nehmende Al- ternative zur klassischen Softwareentwicklung angesehen werden. Im Zuge des Entwick- lungsprozesses der modellgetriebenen Softwareentwicklung sind in den letzten Jahren auch zahlreiche Methoden zur Modelltransformation entwickelt worden. Viele dieser Ansätze basieren auf den Metamodellen der jeweiligen Modellierungssprachen und setzen daher ein Wissen über die abstrakte Syntax voraus, das für die Modellierung von Modellen mit eben diesen Sprachen nicht notwendig ist. Aufgrund dieser Einschränkungen heutiger Modelltransformationsansätze entstand die Idee zu Model Transformation By-Example (MTBE), welches auf beispielgetriebenen Me- thoden basiert. Dieser Ansatz ermöglicht BenutzerInnen mit geeigneten Mappingopera- toren semantische Beziehungen zwischen Elementen, definiert in einer konkreten Syntax, zu spezifizieren. Auf diese Weise lassen sich Modelltransformationen und semantische Beziehungen benutzerfreundlicher spezifizieren als dies auf der Metamodellebene der Fall wäre. Das Wissen der BenutzerInnen über die konkrete Syntax einer Modellierungssprache und die Bedeutung der Mappingoperatoren genügen in den meisten Fällen, um Modell- transformationen zu erzeugen. Der MTBE-Ansatz unterstützt die Spezifikation von weit- eren Mapping-Operatoren. Im Rahmen der Dissertation wurden Mapping-Operatoren für Sprachen zur Strukturmodellierung und zur Verhaltensmodellierung entwickelt. Die An- zahl der Mappingoperatoren wurde bewusst niedrig gehalten, um die Überschaubarkeit und Benutzerfreundlichkeit nicht zu gefährden. Der dadurch entstandene Verlust an Aus- drucksstärke wurde durch Reasoningalgorithmen, sowohl auf der Metamodell- als auch auf der Modellebene größtenteils kompensiert, um ausführbaren Transformationscode ge- nerieren zu können. Neben der konzeptuellen Definition von MTBE ist für den Nachweis der Praxis- tauglichkeit auch eine Werkzeugunterstützung gefordert, welche die Möglichkeit zum Modellmapping und zur Generierung von Transformationscode bietet. Daher wurde ein Framework konzipiert und umgesetzt, das auf bewährten Modellierungsanwendungen der Eclipse-Umgebung aufbaut. Zu diesen Anwendungen zählen etwa das Eclipse Modeling Framework (EMF), das Graphical Modeling Framework (GMF), die Atlas Transformation Language (ATL) und der Atlas Model Weaver (AMW). Schließlich wurde MTBE anhand von zwei Fallstudien getestet und evaluiert. Diese bei- den Fallstudien decken sowohl Struktur- als auch Verhaltensmodellierung ab. v vi Contents Danksagung i Abstract iii Kurzfassung v 1 Introduction 1 1.1 Motivation . 1 1.2 Existing Work . 2 1.3 Contribution of the Thesis . 3 1.4 Big Picture and Structure of the Thesis . 5 2 State of the Art 7 2.1 Introduction to Model Transformation . 7 2.2 Some Model Transformation Approaches in Detail . 8 2.2.1 QVT . 8 2.2.2 ATL . 9 2.2.3 Graph Grammars . 10 2.2.4 Advanced Model Transformation Features . 12 2.3 Why We Benefit from Examples? . 13 2.4 Common By-Example Approaches . 14 2.4.1 Query By Example . 15 2.4.2 Programming By-Example . 17 2.4.3 Web-Scheme Transformers By-Example . 18 3 Prerequisites for MTBE 21 3.1 The Metamodeling Stack . 22 3.1.1 The Ecore Model - Core Concepts Reviewed . 22 3.1.2 Differences between Ecore and MOF . 23 3.1.3 Models and Transformations . 25 3.1.4 Horizontal vs. Vertical Model Transformations . 26 3.2 Metamodel Heterogeneities . 27 3.2.1 Attribute Conflicts . 28 vii 3.2.2 Structural Conflicts . 30 3.2.3 Semantic Conflicts . 33 3.3 Model Heterogeneities . 35 3.4 Refactoring Patterns . 36 3.4.1 Patterns for Reification of Concepts . 37 3.4.2 Patterns for Elimination of Abstract Concepts . 38 3.4.3 Patterns for Explicit Specialization of Concepts . 38 3.4.4 Patterns for Exploring Combinations of Refactored Concepts . 40 3.5 Concrete Syntax vs. Notation . 41 3.6 Metamodel Metrics . 43 3.6.1 Calculating the Explicitness of Metamodels . 44 3.6.2 Analysing UML 1.4 and UML 2.1 . 47 3.6.3 Metrics-Related Work . 49 3.7 Requirements for Example Models . 50 4 Basic MTBE Concepts 55 4.1 Shortcomings of Current Model Transformation Approaches . 55 4.2 A Five Step Process for MTBE . 59 4.3 A Running Example . 61 4.4 MTBE Frontend - The Black-Box View . 62 4.4.1 Model Mapping . 62 4.4.2 Mapping Definitions By-Example . 64 4.4.3 Validation of Transformation Code and Produced Output Models . 65 4.5 MTBE Backend - The White-Box View . 66 4.5.1 Basic Reasoning on User Mappings By-Example . 66 4.5.2 Metamodel Mapping . 70 4.5.3 Transformation Model Generation By-Example . 70 4.6 MTBE-Related Work . 71 4.7 Summary . 73 5 Advanced MTBE Concepts 75 5.1 Adding Expressiveness to the Model Mapping Language . 75 5.2 Reasoning based Pattern Matching . 79 5.3 Adding Expressiveness to the Metamodel Mapping Language . 81 5.4 Advanced Reasoning Algorithms . 83 5.5 A Two Step Transformation Process . 84 6 Implementation 87 6.1 Overview of the Graphical Modeling Framework . 87 6.2 An Eclipse Based Implementation for MTBE . 91 viii 6.2.1 MTBE Workbench . 93 6.2.2 Integration of GMF . 93 6.3 Critical Discussion . 96 6.3.1 Implementation Status . 96 6.3.2 Discussing the GMF Approach . 96 6.3.3 Alternative Implementation Approaches . 96 6.4 Summary . 97 7 Applications of MTBE 99 7.1 Application to Structural Modeling Languages . 99 7.1.1 Integration Problem: ER2UML . 100 7.1.2 User defined Model Mappings . 101 7.1.3 Reasoning and Metamodel Mappings . 103 7.1.4 ATL Code Generation . 103 7.2 Application to Behavioral Modeling Languages . 106 7.2.1 Models for Business Processes . 106 7.2.2 Dealing with Heterogeneities in Business Procss Models . 108 7.2.3 Integration Problem: UML AD and EPC . 110 7.2.4 Model Mappings and Metamodel Mappings . 110 7.3 Critical Discussion . 117 8 Open Issues and Future Work 119 Bibliography 121 Curriculum Vitae 129 ix x List of Figures 1.1 Model transformation pattern according to [21]. 1 1.2 Typical distribution of knowledge considering software architects. 3 1.3 Big picture of this thesis. 5 2.1 Relationships between QVT metamodels [70]. 9 2.2 PacMan type graph. 11 2.3 Instance graph for the PacMan type graph. 11 2.4 Graph transformation rule that moves PacMan.
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]
  • Model Transformation Languages Under a Magnifying Glass:A Controlled Experiment with Xtend, ATL, And
    CORE Metadata, citation and similar papers at core.ac.uk Provided by The IT University of Copenhagen's Repository Model Transformation Languages under a Magnifying Glass: A Controlled Experiment with Xtend, ATL, and QVT Regina Hebig Christoph Seidl Thorsten Berger Chalmers | University of Gothenburg Technische Universität Braunschweig Chalmers | University of Gothenburg Sweden Germany Sweden John Kook Pedersen Andrzej Wąsowski IT University of Copenhagen IT University of Copenhagen Denmark Denmark ABSTRACT NamedElement name : EString In Model-Driven Software Development, models are automatically processed to support the creation, build, and execution of systems. A large variety of dedicated model-transformation languages exists, Project Package Class StructuralElement modifiers : Modifier promising to efficiently realize the automated processing of models. [0..*] packages To investigate the actual benefit of using such specialized languages, [0..*] subpackages [0..*] elements Modifier [0..*] classes we performed a large-scale controlled experiment in which over 78 PUBLIC STATIC subjects solve 231 individual tasks using three languages. The exper- FINAL Attribute Method iment sheds light on commonalities and differences between model PRIVATE transformation languages (ATL, QVT-O) and on benefits of using them in common development tasks (comprehension, change, and Figure 1: Syntax model for source code creation) against a modern general-purpose language (Xtend). Our results show no statistically significant benefit of using a dedicated 1 INTRODUCTION transformation language over a modern general-purpose language. In Model-Driven Software Development (MDSD) [9, 35, 38] models However, we were able to identify several aspects of transformation are automatically processed to support creation, build and execution programming where domain-specific transformation languages do of systems.
    [Show full text]
  • The Viatra-I Model Transformation Framework Users' Guide
    The Viatra-I Model Transformation Framework Users’ Guide c 2007. OptXware Research and Development LLC. This document is property of the OptXware Research and Development LLC. To copy the whole or parts of it, or passing the contained information to third parties is allowed only with prior approval of OptXware Research and Development LLC. Contents 1 Introduction 6 1.1 The VIATRA Model Transformation Framework ... 6 1.1.1 Mission statement ................ 6 1.1.2 Target application domains ........... 6 1.1.3 The approach ................... 7 1.2 The Current Release ................... 7 1.2.1 Product features ................. 7 1.2.2 The Development Team ............. 9 2 Graphical User Interface of VIATRA 10 2.1 Initial Steps with Using VIATRA ............ 10 2.1.1 Installation .................... 10 2.1.2 Setting up the VIATRA environment in Eclipse 17 2.1.3 Creating a new project .............. 19 2.1.4 Creating a model space ............. 21 2.1.5 Opening and saving a model space ....... 23 2.1.6 Creating a metamodel or transformation .... 25 2.1.7 Parsing a metamodel or transformation .... 27 2.1.8 Executing a transformation ........... 31 2.2 Syntax for Format String in the Tree Editor ...... 32 2.2.1 Supported property names ........... 33 2.2.2 Examples ..................... 34 2 Contents 3 3 Writing Import Modules 36 3.1 Creating a meta model .................. 36 3.2 Handling concrete syntax ................ 37 3.3 Building up models .................... 38 3.4 Structure of an import plugin .............. 40 3.5 Installing a new importer ................ 42 4 Writing New Native Functions for VIATRA 43 4.1 Implementing a New Function .............
    [Show full text]
  • Data Transformation Language (DTL)
    DTL Data Transformation Language Phillip H. Sherrod Copyright © 2005-2006 All rights reserved www.dtreg.com DTL is a full programming language built into the DTREG program. DTL makes it easy to generate new variables, transform and combine input variables and select records to be used in the analysis. Contents Contents...................................................................................................................................................3 Introduction .............................................................................................................................................6 Introduction to the DTL Language......................................................................................................6 Using DTL For Data Transformations ....................................................................................................7 The main() function.............................................................................................................................7 Global Variables..................................................................................................................................8 Implicit Global Variables ................................................................................................................8 Explicit Global Variables ................................................................................................................9 Static Global Variables..................................................................................................................11
    [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]
  • A Framework for Model Transformation Verification LANO, Kevin, CLARK, T
    A framework for model transformation verification LANO, Kevin, CLARK, T. <http://orcid.org/0000-0003-3167-0739> and KOLAHDOUZ-RAHIMI, S. Available from Sheffield Hallam University Research Archive (SHURA) at: http://shura.shu.ac.uk/12046/ This document is the author deposited version. You are advised to consult the publisher's version if you wish to cite from it. Published version LANO, Kevin, CLARK, T. and KOLAHDOUZ-RAHIMI, S. (2015). A framework for model transformation verification. Formal Aspects of Computing, 27 (1), 193-235. Copyright and re-use policy See http://shura.shu.ac.uk/information.html Sheffield Hallam University Research Archive http://shura.shu.ac.uk A framework for verification of model transformations K. Lano, T. Clark, S. Kolahdouz-Rahimi Dept. of Informatics, King's College London; Dept. of Informatics, Middlesex University Abstract. A model transformation verification task may involve a number of different trans- formations, from one or more of a wide range of different model transformation languages, each transformation may have a particular transformation style, and there are a number of different verification properties which can be verified for each language and style of transfor- mation. Transformations may operate upon many different modelling languages. This diver- sity of languages and properties indicates the need for a suitably generic framework for model transformation verification, independent of particular model transformation languages, and able to provide support for systematic procedures for verification across a range of languages, and for a range of properties. In this paper we describe the elements of such a framework, and apply this framework to a range of transformation verification problems.
    [Show full text]
  • Model-Based Hardware Generation and Programming - the MADES Approach
    1 Model-based hardware generation and programming - the MADES approach Ian Gray∗, Nikos Matragkas∗, Neil C. Audsley, Leandro Soares Indrusiak, Dimitris Kolovos, Richard Paige University of York, York, U.K. F Abstract—This paper gives an overview of the model-based hardware the proposed hardware development flow and the way generation and programming approach proposed within the MADES that embedded software can be targeted at the resulting project. MADES aims to develop a model-driven development process complex architectures. for safety-critical, real-time embedded systems. MADES defines a sys- tems modelling language based on subsets of MARTE and SysML that allows iterative refinement from high-level specification down to 1.1 MADES Project Goals final implementation. The MADES project specifically focusses on three The MADES project (Model-based methods and tools unique features which differentiate it from existing model-driven develop- ment frameworks. First, model transformations in the Epsilon modelling for Avionics and surveillance embeddeD systEmS) aims framework are used to move between system models and provide to develop the elements of a fully model-driven ap- traceability. Second, the Zot verification tool is employed to allow early proach for the design, validation, simulation, and code and frequent verification of the system being developed. Third, Compile- generation of complex embedded systems to improve Time Virtualisation is used to automatically retarget architecturally- the current practice in the field. MADES differentiates neutral software for execution on complex embedded architectures. itself from similar projects in that way that it covers This paper concentrates on MADES’s approach to the specification of hardware and the way in which software is refactored by Compile-Time all the phases of the development process: from system Virtualisation.
    [Show full text]
  • Feather: a Feature Model Transformation Language
    1 Feather: A Feature Model Transformation Language Ahmet Serkan Karataş * area of usage to include dynamic systems that can face Abstract: Feature modeling has been a very popular approach fluctuating context conditions, changing user requirements, for variability management in software product lines. Building need to include and facilitate novel resources rapidly, and so on. a feature model requires substantial domain expertise, however, The constant need for adaptation required to enhance the even experts cannot foresee all future possibilities. Changing variability management capabilities of SPLs to cover runtime, requirements can force a feature model to evolve in order to which gave birth to the dynamic software product lines adapt to the new conditions. Feather is a language to describe (DSPLs). In addition to the properties they inherit from SPLs, model transformations that will evolve a feature model. This DSPLs have several other properties such as dynamic article presents the structure and foundations of Feather. First, variability management, flexible variation points and binding the language elements, which consist of declarations to times, context awareness, and self-adaptability [21]. characterize the model to evolve and commands to manipulate A major factor affecting the success of a software product its structure, are introduced. Then, semantics grounding in line, classic or dynamic, is the variability management activity feature model properties are given for the commands in order it incorporates [12]. In the literature there are reports of various to provide precise command definitions. Next, an interpreter variability modeling and management approaches such as that can realize the transformations described by the commands in a Feather script is presented.
    [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]
  • Model Transformation Design Patterns
    Model Transformation Design Patterns Hüseyin Ergin [email protected] Department of Computer Science, University of Alabama, U.S.A. Abstract. In this document, a brief overview of my doctoral research is pre- sented. In model-driven engineering (MDE), most problems are solved using model transformation. An efficient process to solving these problems is to apply reusable patterns while solving them. Finding reusable design patterns to specific subsets of problems helps to decrease the time and cost needed to solve them. My doctoral research is based on finding these design patterns to be applied on model transformation problems and evaluating them in terms of quality criteria. My next step is to generate these design pattern instances automatically by using higher-order transformation. 1 Introduction Model-driven engineering (MDE) [1] is considered a well-established software devel- opment approach that uses abstraction to bridge the gap between the problem and the software implementation. These abstractions are defined as models. Models are primary artifacts in MDE and are used to describe complex systems at multiple levels of abstrac- tion, while capturing some of their essential properties. These levels of abstraction let domain experts describe and solve problems without depending on a specific platform or programming language. Models are instances of a meta-model which defines the syntax of a modeling lan- guage. In MDE, the core development process consists of a series of transformations over models, called model transformation. Model transformations take models as input and output according to the specifications defined by the meta-model. In this document, I summarize the subject that I want to work on in my dissertation.
    [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]