Elsevier

Journal of Systems and Software

Volume 111, January 2016, Pages 272-280
Journal of Systems and Software

Evolving models in Model-Driven Engineering: State-of-the-art and future challenges

https://doi.org/10.1016/j.jss.2015.08.047Get rights and content

Highlights

  • A conceptual overview of the problem of model evolution.

  • A survey of the state-of-the-art in model evolution and migration.

  • Open and ongoing research challenges in model evolution and migration.

Abstract

The artefacts used in Model-Driven Engineering (MDE) evolve as a matter of course: models are modified and updated as part of the engineering process; metamodels change as a result of domain analysis and standardisation efforts; and the operations applied to models change as engineering requirements change. MDE artefacts are inter-related, and simultaneously constrain each other, making evolution a challenge to manage. We discuss some of the key problems of evolution in MDE, summarise the key state-of-the-art, and look forward to new challenges in research in this area.

Introduction

Software engineering – like many engineering disciplines – is all about managing constraints: on the systems we want to build, those that come from the development and business processes we operate, those from the organisational context in which we work, and those from the people who build the software. These constraints must be specified, related, and managed to ensure that we build software that satisfies its requirements and does not invalidate its contextual obligations. Different software engineering approaches and methodologies attempt to manage constraints in different ways. Some approaches treat constraints as mathematical entities, and develop rigorous theories for their manipulation and management (e.g., Diller, 1990). Others treat constraints informally and deploy software engineering practices (such as use of metaphors and pair programming) to manage them indirectly (e.g., Beck, 1999). Many approaches fit in between these two perspectives.

Model-Driven Engineering (MDE) (Kent, 2002) is a modern software engineering approach that attempts to present a unified conceptual model for how systems engineering should take place. Engineering builds and operates on precise and structured models which are created for a particular purpose, and are themselves manipulated by software tools (e.g., for generating code) (Schmidt, 2006). Software engineering processes therefore involve constructing, storing, modifying, analysing and destroying models. Substantial research has been carried out on MDE, and many excellent tools exist to support different MDE tasks (such as generating code from abstract models) (e.g., Kolovos, openArchitectureWare, Group, mbeddr Team).

The models created when using MDE typically are defined in modelling languages, which are precisely specified and defined using metamodels (Paige et al., 2014). Metamodels are, informally, a set of constraints that distinguish well-formed from ill-formed models: a valid model is said to conform to its metamodel. A metamodel describes the abstract syntax, and certain static semantic properties (such as multiplicities of elements involved in relationships) of modelling languages. This is, at least superficially, no different from other language-oriented approaches to software engineering, such as formal methods, where a precisely defined language is used to specify artefacts, and those artefacts are manipulated over the course of development. However, MDE has a number of significant differences.

  • Tools come first in MDE: The modelling languages that are used are designed so as to be supported by tools that software engineers are familiar with and expect to be able to use – e.g., editors, syntax highlighters, debuggers, etc. Standard frameworks, such as EMF (Steinberg et al., 2008), exist to help define modelling languages in such a way so as to support this. In contrast, formal specification languages are designed to support mathematical reasoning, and as such the priority is to have a sound and complete mathematical semantics, which thereafter be supported by tools.

  • Automated processing of models: Models are meant to be processed by tools. This is the discipline of model management (Ruscio, Eramo, Pierantonio, 2012, Paige, Kolovos, Rose, Matragkas, Williams, 2011). Typical model management tasks include transformation, comparison, merging, migration, validation and text generation, though the specific tasks that are used in industrial application are driven and dictated by engineering process and organisational context (e.g., use of automated code generation from models that enables audit and inspection).

  • Languages are themselves models: A metamodel is itself a model, and can be instantiated; in some interpretations of MDE, the operations on models (e.g., transformations) are also models with their own metamodels. Metamodels are also instances of so-called metametamodels, thus (at least conceptually) making it easier to build generic tools that support a wide variety of languages and modelling styles.

Models provide a unified conceptual way of thinking about and carrying out software engineering, and the tools that exist can help to make certain aspects of MDE work in practice (Bézivin, 2005). But use of models is not without significant challenges. Software engineering must always be prepared to deal with change: of requirements, of technology platforms, of developers, etc. In some cases, change and its impact on software engineering may be difficult to identify or assess. Both challenges and opportunities arise with managing change in MDE. One significant opportunity comes from MDE making dependencies between artefacts (models, metamodels, operations on models) – typically in the form of constraints – explicit: these relationships can, in principle, be used to identify and calculate the impact of changes (to models, metamodels, operations) on other artefacts. A challenge arises from the significant number of constraints in place in MDE: models, metamodels and operations thereupon are effectively sets of constraints on what can be specified, and what can be done to those specifications. MDE can be reduced, conceptually, to a heterogeneous constraint management problem: trying to building satisfiable sets of different kinds of constraints whose instances are solutions to important problems. A similar argument could be made for other system or software engineering disciplines, though MDE makes the dependencies and hence constraints explicit.

A significant issue associated with constraint management in any discipline is dealing with change: change in the structures to which constraints are applied; changes to individual constraints; changes to sets of constraints; or changes to the tools that evaluate constraints on structures. Constraints invariably depend on each other, so making even small changes can have significant impact on other, related artefacts. Change management for MDE is a particular instance of this problem, and there are many specialisations within MDE. One that has seen particular recent interest is model evolution: models changing over time, typically in response to some kind of external event. Numerous approaches have been developed to help systematise the process of model evolution. In this paper, we highlight the state-of-the-art in model evolution, and relate it to future challenges in research in this area. But first, we briefly contextualise the discussion by providing a short overview of evolution in MDE in general, before turning to our survey.

Section snippets

Context: evolution in MDE

When building systems using MDE, the trinity of artefacts that is used is:

  • Metamodels, which describe the structures and rules applicable for a family of models (metamodels themselves are models, which conform to a metametamodel).

  • Models, which are particular instances of structures and rules.

  • Operations, which are defined on metamodels and apply to models (e.g., transformation, comparison, merging). Operations may have side-effects: particuarly, they may generate trace-links which relate model

State-of-the-art

In this section we describe the state-of-the-art in managing evolution in MDE. We consider solutions in a number of categories, and consider the key research findings and technological results.

Challenges

There has been substantial research in models and evolution over the past ten years, but numerous challenges remain; some are technical and theoretical, others are more focused on engineering practice and process. We identify some of the key ongoing challenges in this section.

Conclusions

The key principle of MDE is automating repetitive and error prone tasks. The decisions that we make, with respect to use of particular technologies and theories, the implementation of particular tasks, and the deployment of workbenches to users, should always aim to support that principle. The techniques and tools that have been developed to support evolution and migration in MDE all address the flexibility-automation tradeoff (like other MDE operations, such as transformation), but in doing so

Acknowledgements

The authors thank the editors for their feedback and for the invitation to write this article.

Richard F. Paige is Professor of Enterprise Systems and Deputy Head of Department, responsible for research, in the Department of Computer Science, University of York, UK. He leads research on modelling, transformation, automated software engineering and enterprise systems in the department. He is on the steering committees of the STAF, ICMT and SLE series of conferences, and on the editorial boards of Empirical Software Engineering, Software and Systems Modelling and the Journal of Object

References (63)

  • LangerP. et al.

    A posteriori operation detection in evolving software models

    J. Syst. Softw.

    (2013)
  • PaigeR.F. et al.

    A tutorial on metamodelling for grammar researchers

    Sci. Comput. Program.

    (2014)
  • AlanenM. et al.

    Difference and Union of Models

    (2003)
  • AltmanningerK. et al.

    Why model versioning research is needed!? An experience report

    Proceedings of the Joint MoDSE-MC02CM 2009 Workshop

    (2009)
  • AltmanningerK. et al.

    AMOR – towards adaptable model versioning

    Proceedings of the 1st International Workshop on Model Co-Evolution and Consistency Management (MCCM’08)

    (2008)
  • ArendtT. et al.

    Henshin: advanced concepts and tools for in-place EMF model transformations

    Model Driven Engineering Languages and Systems

    (2010)
  • BeckK.

    Embracing change with extreme programming

    Computer

    (1999)
  • BeineM. et al.

    Bidirectional transformations in database evolution: a case study “at scale”

    Proceedings of the EDBT/ICDT Workshops

    (2014)
  • BézivinJ.

    On the unification power of models

    Softw. Syst. Modeling

    (2005)
  • BroschP. et al.

    An introduction to model versioning

    Proceedings of the 12th International Conference on Formal Methods for the Design of Computer, Communication, and Software Systems: Formal Methods for Model-driven Engineering

    (2012)
  • BudinskyF. et al.

    Eclipse Modeling Framework

    (2003)
  • CicchettiA. et al.

    Managing model conflicts in distributed development

  • CicchettiA. et al.

    Managing dependent changes in coupled evolution

    Proceedings of International Conference on Multimedia Technology, ICMT

    (2009)
  • DebruyneV. et al.

    EAST-ADL: an architecture description language

    Architecture Description Languages

    (2005)
  • DemuthA. et al.

    Co-evolution of metamodels and models through consistent change propagation

    Proceedings of International Workshop on Models and Evolution, ME@MoDELS

    (2013)
  • Di RuscioD. et al.

    Managing the coupled evolution of metamodels and textual concrete syntax specifications

    Proceedings of the 39th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA)

    (2013)
  • DillerA.

    Z: An Introduction to Formal Methods

    (1990)
  • DiskinZ. et al.

    Mapping-aware megamodeling: design patterns and laws

    Proceedings of Software Language Engineering, SLE

    (2013)
  • DiskinZ. et al.

    Category theory and model-driven engineering: from formal semantics to design patterns and beyond

    Proceedings of Workshop on Applied and Computational Category Theory, ACCAT

    (2012)
  • EhrigH. et al.

    A formal resolution strategy for operation-based conflicts in model versioning using graph modifications

  • EstublierJ. et al.

    Impact of software engineering research on the practice of software configuration management

    ACM Trans. Softw. Eng. Methodol.

    (2005)
  • FosterJ.N. et al.

    Combinators for bidirectional tree transformations: a linguistic approach to the view-update problem

    ACM Trans.Program. Lang. Syst.

    (2007)
  • FürstS. et al.

    AUTOSAR – a worldwide standard is on the road

    Proceedings of the 14th International VDI Congress Electronic Systems for Vehicles

    (2009)
  • GarcésK. et al.

    Managing model adaptation by precise detection of metamodel changes

    Proceedings of European Conference on Model Driven Architecture – Foundations and Applications, ECMDA-FA

    (2009)
  • GieseH. et al.

    Incremental model synchronization with triple graph grammars

    Proceedings of the 9th International Conference on Model Driven Engineering Languages and Systems (MoDELS), Genova, Italy

    (2006)
  • Group, A., 2007. Atlas Transformation Language Project....
  • GruschkoB. et al.

    Towards synchronizing models with evolving metamodels

    Proceedings of Workshop on Model-Driven Software Evolution (MODSE), 11th European Conference on Software Maintenance and Reengineering

    (2007)
  • HerrmannsdoerferM.

    COPE – a workbench for the coupled evolution of metamodels and models

    Proceedings of Software Language Engineering, SLE

    (2010)
  • Hussey, K., Paternostro, M., 2006. Advanced features of EMF. Tutorial at EclipseCon 2006, California, USA. Available...
  • JouaultF. et al.

    ATL: a QVT-like transformation language

    Companion to the 21st ACM SIGPLAN Symposium on Object-oriented Programming Systems, Languages, and Applications

    (2006)
  • KentS.

    Model driven engineering

    Integrated Formal Methods

    (2002)
  • Cited by (58)

    View all citing articles on Scopus

    Richard F. Paige is Professor of Enterprise Systems and Deputy Head of Department, responsible for research, in the Department of Computer Science, University of York, UK. He leads research on modelling, transformation, automated software engineering and enterprise systems in the department. He is on the steering committees of the STAF, ICMT and SLE series of conferences, and on the editorial boards of Empirical Software Engineering, Software and Systems Modelling and the Journal of Object Technology.

    Nicholas Matragkas is Lecturer in Computer Science at the University of Hull, UK; previously he was a research associate at the University of York. His expertise is in modelling, traceability, domain-specific languages and open-source analytics.

    Louis Rose is a Lecturer in Enterprise Systems at the University of York, UK. He specialises in software maintenance and evolution, mutation testing and cloud computing. He is one of the organisers of the Transformation Tools Contest.

    View full text