MODEVO

Model-driven Software Evolution

This work programme focuses on the development of model-driven concepts and techniques for the engineering of variable and evolving software systems.

In particular, it aims to:

Develop concepts and techniques for the configuration of complex software intensive systems (Task 2)
Develop concepts and techniques to plan, manage, and monitor evolution of such variable software-intensive systems (Task 3)
As a foundation for Tasks 2 and 3, develop a modelling framework that integrates concepts from variability modelling and software evolution (Task 1)
Evaluate the results in industrial case studies (Task 4)
Disseminate the results (Task 5)

The development of complex software-intensive systems requires a systematic approach and a long term commitment of resources. Consequently, companies that provide such systems plan the evolution of their product portfolios over many years ahead. This need for evolution is driven by the fact that software intensive systems have to be continuously evolved; otherwise they would lose their value or become obsolete [1]. This software evolution, in particular if it affects critical software systems, is a common and complex problem involving all phases of a software engineering process [2].

In addition, such companies often provide families of similar products, which share common features, but differ in certain distinguishing characteristics. A good example is engine management software in cars.

This work programme aims to address these two challenges of evolution and variability by adapting, and applying concepts and techniques from Model-driven Engineering (MDE) [3]. In the context of model-driven development, one can distinguish between different dimensions of evolution [4]: besides changing the application itself (i.e., the model level), evolution needs to be considered at the level of meta-models and transformations (meta-model evolution), at the level of code generators and application frameworks (platform evolution), and at the different layers of abstraction covered by modelling languages (abstraction evolution).

We focus in particular on evolution and variability of complex software-intensive systems, where the complexity is caused, for instance, by the sheer size of the systems, the systems-of-systems nature, or the complexity of the corresponding context (e.g., design and development in collaborative and distributed organisational structures).

Appropriate support for very large software systems and critical systems is essential. Therefore, we intend to integrate (1) concepts from model-driven engineering in-the-large and (2) variability modelling and other concepts from software product line engineering (PLE) to deal with evolution in product lines and product families.

Even though current results in product configuration are promising, the available approaches are not sufficient when it comes to covering the requirements posed by large-scale industrial applications. This is caused by the following shortcomings:

Currently available modelling languages are not expressive enough to describe the configuration problems, in particular (1) when it comes to the integration of configuration models with other artefacts and (2) in scenarios where the configuration of systems-of-systems need be represented and implemented.
The involved interaction techniques available today are not adequate for very large models. When moving towards larger models (e.g., 50-300 elements), tree-oriented models initially seem to provide additional overview, because they provide a representation of a logical structure. However, when operating on even larger models (e.g., 500-10,000 elements and high ratio of “cross-tree” constraints), experience indicates that a simple tree-oriented interaction becomes too complex as an interaction paradigm for typical configuration tasks.
The integration between reasoning and interactive techniques is not sufficient, in particular when it comes to task- and domain-specific support in product line engineering.
There is insufficient support for collaborative configuration, e.g., views for stakeholders, resolution of conflicts.

Similar issues apply to software evolution in the context of model-driven approaches. Evolution is already addressed by a number of powerful, yet isolated concepts available in model-driven software engineering today, e.g., traceability, model synchronization, and automated transformations. Current research in MDE aims to provide further foundations for the integration of these evolution levels [5-6], e.g. by unifying languages for transformations, and by providing a unified framework for inconsistency management.

Model-based Evolution Planning

Figure 1 shows the basic conceptual framework for this project. The vertical dimension shows the different levels of abstraction. According to model-driven engineering, an application can be represented by different models on different abstraction levels. Automated model transformations enable the transformation of abstract models step-by-step into more concrete ones and finally into code (top to bottom in the figure). During

transformation, traceability links are established automatically between source and target elements.

Figure 1 – Synchronization of Evolution on different abstraction levels

The horizontal axis represents the temporal dimension along which the evolution takes place. At given point in time, there is a history of previous evolution steps. However, the information about future evolution steps is incomplete, as future plans are defined only incrementally and for some parts of the system and some abstraction levels.

The modelling languages and the corresponding tool suite developed in this work programme will allow the specification, management, and monitoring of the evolution. Therefore, it will leverage state-of-the-art concepts like model synchronization based on traceability or inconsistency management. The evolution planning and the evolution itself will also be specified in terms of models. In addition, the tool suite will provide visualizations and interaction techniques tailored for the typical tasks to handle evolution.

Similar to the evolution step from programming-in-the-small to software engineering, model-driven software engineering has to evolve to a level where very large and complex projects can be handled. Hence, we propose to develop an integrated approach that relies on model-driven engineering in-the-large ([7], also known as “global model management” or “megamodelling”) and fosters a global view of the considered artefacts.

References

[1] M. M. Lehman, "Laws of Software Evolution Revisited," in EWSPT, 1996, pp. 108-124.

[2] M. Hinchey and L. Coyle, "Evolving Critical Systems," Lero - The Irish Software Engineering Research Centre, University of Limerick, Ireland Lero-TR-2009-00, June 2009.

[3] T. Stahl and M. Voelter, Model-driven software development: technology, engineering, management. Chichester, England; Hoboken, NJ, USA: John Wiley, 2006.

[4] A. van Deursen, et al., "Model-Driven Software Evolution: A Research Agenda," in CSMR Workshop on Model-Driven Software Evolution (MoDSE 2007), Amsterdam, The Netherlands, 2007, pp. 41-49.

[5] "MoDSE Project (Model-Driven Software Evolution)," ed: Website.

[6] "Moves Project (Modelling, Verification and Evolution of Software)," ed: Website.

[7] J. Bezivin, et al., "On the Need for Megamodels," in Proceedings of Workshop on Best Practices for Model-Driven Software Development at the 19th Annual ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications., Vancouver, British Columbia, Canada, 2004.