Evolving models in Model-Driven Engineering: State-of-the-art and future challenges
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)
- et al.
A posteriori operation detection in evolving software models
J. Syst. Softw.
(2013) - et al.
A tutorial on metamodelling for grammar researchers
Sci. Comput. Program.
(2014) - et al.
Difference and Union of Models
(2003) - et al.
Why model versioning research is needed!? An experience report
Proceedings of the Joint MoDSE-MC02CM 2009 Workshop
(2009) - et al.
AMOR – towards adaptable model versioning
Proceedings of the 1st International Workshop on Model Co-Evolution and Consistency Management (MCCM’08)
(2008) - et al.
Henshin: advanced concepts and tools for in-place EMF model transformations
Model Driven Engineering Languages and Systems
(2010) Embracing change with extreme programming
Computer
(1999)- et al.
Bidirectional transformations in database evolution: a case study “at scale”
Proceedings of the EDBT/ICDT Workshops
(2014) On the unification power of models
Softw. Syst. Modeling
(2005)- 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)
Eclipse Modeling Framework
Managing model conflicts in distributed development
Managing dependent changes in coupled evolution
Proceedings of International Conference on Multimedia Technology, ICMT
EAST-ADL: an architecture description language
Architecture Description Languages
Co-evolution of metamodels and models through consistent change propagation
Proceedings of International Workshop on Models and Evolution, ME@MoDELS
Managing the coupled evolution of metamodels and textual concrete syntax specifications
Proceedings of the 39th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA)
Z: An Introduction to Formal Methods
Mapping-aware megamodeling: design patterns and laws
Proceedings of Software Language Engineering, SLE
Category theory and model-driven engineering: from formal semantics to design patterns and beyond
Proceedings of Workshop on Applied and Computational Category Theory, ACCAT
A formal resolution strategy for operation-based conflicts in model versioning using graph modifications
Impact of software engineering research on the practice of software configuration management
ACM Trans. Softw. Eng. Methodol.
Combinators for bidirectional tree transformations: a linguistic approach to the view-update problem
ACM Trans.Program. Lang. Syst.
AUTOSAR – a worldwide standard is on the road
Proceedings of the 14th International VDI Congress Electronic Systems for Vehicles
Managing model adaptation by precise detection of metamodel changes
Proceedings of European Conference on Model Driven Architecture – Foundations and Applications, ECMDA-FA
Incremental model synchronization with triple graph grammars
Proceedings of the 9th International Conference on Model Driven Engineering Languages and Systems (MoDELS), Genova, Italy
Towards synchronizing models with evolving metamodels
Proceedings of Workshop on Model-Driven Software Evolution (MODSE), 11th European Conference on Software Maintenance and Reengineering
COPE – a workbench for the coupled evolution of metamodels and models
Proceedings of Software Language Engineering, SLE
ATL: a QVT-like transformation language
Companion to the 21st ACM SIGPLAN Symposium on Object-oriented Programming Systems, Languages, and Applications
Model driven engineering
Integrated Formal Methods
Cited by (58)
Supporting reusable model migration with Edelta
2024, Journal of Systems and SoftwareTyping Requirement Model as Coroutines
2024, IEEE AccessModel-Driven Code Generation for Microservices: Service Models
2023, OpenAccess Series in InformaticsA Formal Approach for Consistency Management in UML Models
2023, International Journal of Software Engineering and Knowledge Engineering
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.