Jim Steel

Transformation: The Missing Link of MDA

In this paper we explore the issue of transforming models to models, an essential part of the OMGs Model Driven Architecture (MDA) vision. Drawing from the literature and our experiences implementing a number of transformations using different technologies, we explore the strengths and weaknesses of the different technologies and identify requirements for a transformation language for performing the kind of model-to-model transformations required to realise the MDA vision.

Practical declarative model transformation with tefkat

We present Tefkat, an implementation of a language designed specifically for the transformation of MOF models using patterns and rules. The language adopts a declarative paradigm, wherein users may concern themselves solely with the relations between the models rather than needing to deal explicitly with issues such as order of rule execution and pattern searching/traversal of input models. In this paper, we demonstrate the language using a provided example and highlight a number of language features used in solving the problem, a simple object-to-relational mapping.

On model typing

Where object-oriented languages deal with objects as described by classes, model-driven development uses models, as graphs of interconnected objects, described by metamodels. A number of new languages have been and continue to be developed for this model-based paradigm, both for model transformation and for general programming using models. Many of these use single-object approaches to typing, derived from solutions found in object-oriented systems, while others use metamodels as model types, but without a clear notion of polymorphism. Both of these approaches lead to brittle and overly restrictive reuse characteristics. In this paper we propose a simple extension to object-oriented typing to better cater for a model-oriented context, including a simple strategy for typing models as a collection of interconnected objects. We suggest extensions to existing type system formalisms to support these concepts and their manipulation. Using a simple example we show how this extended approach permits more flexible reuse, while preserving type safety.

Validation in model-driven engineering: testing model transformations

The OMGs model-driven architecture is quickly attracting attention as a method of constructing systems that offers advantages over traditional approaches in terms of reliability, consistency, and maintainability. The key concepts in the MDA are models that are related by model transformations. However, for the MDA to provide an adequate alternative to existing approaches, it must offer comparable support for software engineering processes such as requirements analysis, design and testing. This paper attempts to explore the application of the last of these processes, testing, to the most novel part of the MDA, that of model transformation. We present a general view of the roles of testing in the different stages of model-driven development, and a more detailed exploration of approaches to testing model transformations. Based on this, we highlight the particular issues for the different testing tasks, including adequacy criteria, test oracles and automatic test data generation. We also propose possible approaches for the testing tasks, and show how existing functional and structural testing techniques can be adapted for use in this new development context.

On model subtyping

Various approaches have recently been proposed to ease the manipulation of models for specific purposes (e.g., automatic model adaptation or reuse of model transformations). Such approaches raise the need for a unified theory that would ease their combination, but would also outline the scope of what can be expected in terms of engineering to put model manipulation into action. In this work, we address this problem from the model substitutability point of view, through model typing. We introduce four mechanisms to achieve model substitutability, each formally defined by a subtyping relation. We then discuss how to declare and check these subtyping relations. This work provides a formal reference specification establishing a family of model-oriented type systems. These type systems enable many facilities that are well known at the programming language level. Such facilities range from abstraction, reuse and safety to impact analyses and auto-completion.

Model transformation: a declarative, reusable patterns approach

The MOF (Meta Object Facility) query, view and transformation RFP, issued by OMG will result in a key enabling technology for model-driven development of large distributed systems. We have designed a transformation language which will meet the requirements of this RFP, and several others besides. The language is declarative and patterns based. Transformation descriptions are explicitly reusable and modular. Rules that make up such descriptions may be aspect-driven, allowing for transformations to be written to address semantic concepts rather than structural features. This paper introduces the language and its rationale, and shows how it is used to solve s small but non-trivial MDA problem.

Model-based test driven development of the Tefkat model-transformation engine

Tefkat is an implementation of a rule- and pattern-based engine for the transformation of models defined using the Object Management Groups (OMG) Model-Driven Architecture (MDA). The process for the development of the engine included the concurrent development of a unit test suite for the engine. The test suite is constructed as a number of models, whose elements comprise the test cases, and which are passed to a test harness for processing. The paper discusses the difficulties and opportunities encountered in the process, and draws implications for the broader problem of testing in a model-driven environment, and of using models for testing.

Anti-Yacc: MOF-to-text

The Object Management Group (OMG) is pursuing its new Model-Driven Architecture (MDA) strategy. The Meta-Object Facility (MOF) is an important technology to support the MDA, both as a general modelling technique but also specifically to support the definition of other modelling systems. The OMG has standardised the generation of repositories based on MOF models. Anti-Yacc is a tool that can be used to extract the contents of a MOF-based repository in textual form. The Anti-Yacc tool takes as input the specification of grammar rules, lexical rules, and MOF-extraction rules, from which a Java program is generated to extract the contents of a MOF-based repository on demand. Anti-Yacc can be used for code generation, interfacing with legacy syntaxes, and general report writing.

Robust Real-Time Synchronization between Textual and Graphical Editors

This paper is a pre-print of: Oskar van Rest, Guido Wachsmuth, Jim Steel, Jorn Guy Sus, Eelco Visser. Robust Real-Time Synchronization between Textual and Graphical Editors. In Keith Duddy, Gerti Kappel, editors, Theory and Practice of Model Transformations, Sixth International Conference, ICMT 2013, Budapest, Hungary, June 18-19, 2013. Proceedings. Lecture Notes in Computer Science, Springer Verlag 2013. In modern Integrated Development Environments (IDEs), textual editors are interactive and can handle intermediate, incomplete, or otherwise erroneous texts while still providing editor services such as syntax highlighting, error marking, outline views, and hover help. In this paper, we present an approach for the robust synchronization of interactive textual and graphical editors. The approach recovers from errors during parsing and text-to-model synchronization, preserves textual and graphical layout in the presence of erroneous texts and models, and provides synchronized editor services such as selection sharing and navigation between editors. It was implemented for synchronizing textual editors generated by the Spoofax language workbench and graphical editors generated by the Graphical Modeling Framework.

Model typing for improving reuse in model-driven engineering

Where object-oriented languages deal with objects as described by classes, model-driven development uses models, as graphs of interconnected objects, described by metamodels. A number of new languages have been and continue to be developed for this model-based paradigm, both for model transformation and for general programming using models. Many of these use single-object approaches to typing, derived from solutions found in object-oriented systems, while others use metamodels as model types, but without a clear notion of polymorphism. Both of these approaches lead to brittle and overly restrictive reuse characteristics. In this paper we propose a simple extension to object-oriented typing to better cater for a model-oriented context, including a simple strategy for typing models as a collection of interconnected objects. Using a simple example we show how this extended approach permits more flexible reuse, while preserving type safety.