Model-Integrating Development (MID) of Software Systems
A Flexible Component-Based Approach
Dr. Mahdi Manesh of Porsche Digital presents the proposal of model-integrating development (MID) as a software engineering approach that enables the systematic development of component-based model-integrating software (MIS).
Disclaimer: This article sketches some of the fundamental concepts recently published in the Software & Systems Modeling journal series. It is just a teaser. We highly recommend reading the full article to understand the approach and its potential. The results are joint work by Mahdi Manesh, Jürgen Ebert, Marvin Grieger and Gregor Engels.
Abstract. Building software that can be easily changed over time and that can be adapted during operation — e.g., by artificial intelligence — is a challenging task. In this short article, we sketch the idea of model-integrating development (MID), an alternative software engineering approach that enables the systematic development of component-based, model-integrating software. MID combines principles from model-driven and component-based development and is based on the central assumption that models (1) and code shall be treated equally as first-class entities of software throughout its life cycle. In particular, MID leverages the added flexibility that comes with models at runtime, i.e., when models are an integral part of running software. The proposed process and software architecture concepts form an alternative way for building flexible and potentially self-adaptive software systems.
Challenge: software needs to be adaptable and self-adaptive
A promising way to develop flexible software systems is to include models that are analyzed, modified, and executed at runtime as an integrated part of a system. Building such model-integrating systems is a challenging task since the respective modeling languages have to be supported comprehensively at runtime. Furthermore, these systems still need to be developable in a modular way by composing them from basic building blocks.
Model-driven development (MDD) and component-based development (CBD) are two established orthogonal approaches that can tackle the mentioned challenges.
- MDD is based on the use of models and modeling languages as first-class entities to systematically engineer software systems.
- CBD enables the engineering of modular systems by facilitating a divide-and-conquer approach with reuse.
However, combining and aligning the individual principles from both approaches is an open research problem.
For some decades, the former separation of software construction and software maintenance has been replaced by the paradigm of continuous software evolution. Lehman’s laws  and Rajlic’s staged model  imply that continuous development and evolution have to be accompanied by refactoring and reengineering measures if an early phaseout of the system shall be avoided.
Thus, software systems need to be modified continuously to suit new customer requirements and to handle emerging conditions as their operating environments evolve. For this purpose, software needs to be flexible. On the one hand, it should be adaptable, i.e., it should be modifiable and changeable with reasonable effort. On the other hand, it should be adaptive, i.e., it should be able to adapt itself permanently at runtime , too.
Solution idea: merging the best of model-driven and component-based development
To achieve flexibility using models, we claim that their integrated use in software and their embedment into a well-structured system should be exploited to a larger extent based on the principles of model-driven development (MDD) [5, 4] and component-based development (CBD) [6,7]. CBD enables the engineering of modular systems by facilitating a divide-and-conquer approach with reuse, and MDD offers the flexibility needed for continuous software evolution. However, combining and aligning the individual principles from both fields is an open research problem .
In this article, we propose model-integrating development (MID) as a software engineering approach that enables the systematic development of component-based model-integrating software (MIS). MID combines principles from MDD and CBD and is based on the central assumption that models and code shall be treated equally as befriended first-class entities of software throughout its life cycle . MID leverages the added flexibility that comes with executable models as an integral part of software. Stable functionality can be still realized with code to ensure good execution performance. Core techniques from the fields of MDD and CBD are combined to support separation of concerns, encapsulation, reuse, adaptability, and even adaptivity.
Model-integrating development (MID) is a software engineering method that covers the systematic design and implementation of MIS, i.e., of all kinds of software which use models during runtime. MID is based on a series of design considerations  with a focus on the symbiosis of modeling languages, software architecture and components. A high-level overview of the core concepts of MID is shown in Fig. 1, including references to the respective sections in the published journal article.
We basically distinguish two perspectives, namely the design time perspective and the runtime perspective. The former view focuses on activities that need to be performed in order to design and implement MIS. Thereby, an emphasis is put on two essential sub-processes. On the one hand, the component-based architecture of the system needs to be designed (Component Engineering, cf. Sect. 3). On the other hand, modeling languages that are used within the system need to be selected. If such languages are not available, existing languages need to be adapted, or new languages need to be specified (Modeling Language Engineering, cf. Sect. 5).
The runtime perspective focuses on the execution of a developed MIS; an exemplary system is described in Sect. 6. The execution of such a component-based system that seamlessly integrates models and code requires a corresponding Infrastructure (cf. Sect. 4). For example, a component infrastructure is needed that manages the life cycle of components, as well as a language infrastructure that implements the modeling languages used.
Concluding remarks and further reading recommendations
Building software products that can be easily changed over time and that can be adapted during operation — e.g., by artificial intelligence — is a challenging task. In this short article, we sketch the idea of model-integrating development (MID), an alternative software engineering approach that enables the systematic development of component-based, model-integrating software. If you like to learn more about the foundations, core concepts, benefits and challenges, please refer to our comprehensive journal article published at Springer where the MID process is described in detail. In particular, this article provides details of the component and modeling language engineering sub-processes and discusses the interrelation between their core activities. The practicability of the proposed solution concept is rationalized based on a reference implementation that provides the basis for a thoroughly described and critically discussed feasibility study (proof-of-concept).
(1) A model in this context is a software model conforming to a modeling language. Prominent languages used in practice are the sub-languages of the unified modeling language (UML) and the business process model and notation (BPMN).
1. Lehman, M.M.: Programs, life cycles, and laws of software evolution. Proc. IEEE 68(9), 1060–1076 (1980)
2. Rajlich, V.T., Bennett, K.H.: A staged model for the software life cycle. IEEE Comput. 33(7), 66–71 (2000)
3. Salehie, M., Tahvildari, L.: Self-adaptive software: landscape and research challenges. ACM Trans. Auton. Adapt. Syst. 4(2), 14:1– 14:42 (2009)
4. Stahl, T., Völter, M.: Model-Driven Software Development.Wiley, Hoboken (2006)
5. Brambilla, M., Cabot, J., Wimmer, M.: Model-driven software engineering in practice. Morgan & Claypool (2012). http://www.mdse-book.com/. Accessed 20 May 2018
6. Crnkovic, I., Sentilles, S., Vulgarakis, A., Chaudron, M.R.V.: A classification framework for software component models. IEEE Trans. Softw. Eng. 37(5), 593–615 (2011)
7. Szyperski, C., Gruntz, D., Murer, S.: Component Software-Beyond Object-Oriented Programming, 2nd edn. Addison-Wesley, Boston (2002)
8. Ciccozzi, F., Tivoli, M., Carlson, J. (eds.): Proceedings of the 1st International Workshop on Model-Driven Engineering for Component-Based Software Systems co-located with ACM/IEEE 17th International Conference on Model Driven Engineering Languages & Systems (MoDELS 2014), Valencia, Spain, CEUR Workshop Proceedings, vol. 1281. CEUR-WS.org (2014). http://ceur-ws.org/Vol-1281
9. Derakhshanmanesh, M., Ebert, J., Engels, G.: Why models and code should be treated as friends. Softwaretechnik-Trends 34(2) (2014)
10. Derakhshanmanesh, M.: Model-Integrating Software Components — Engineering Flexible Software Systems. Springer, Berlin (2015)