Models@run.time for Engineering Self-adaptive Software Systems
Software implementing real world applications must be continuously adapted to changes in its environment or requirements to remain useful for the user (cf. Lehman’s laws of software evolution). Meanwhile, traditional maintenance approaches that completely stop and exchange a running system to realize adaptation are not in line with context and self-aware, mission-critical, or ultra-large-scale software system. For example, our society or economy heavily depend on information technology, which requires the permanent availability of mission-critical systems. Thus, new approaches are needed to adapt a software system while it is running. This and increasing maintenance costs have led to the vision of Self-Adaptive Software: while being operational, such a software system automatically adjusts its behavior in response to changes in its environment, requirements, or in the system itself. Nevertheless, a self-adaptive software system still has to be open for (typical) software maintenance and evolution approaches.
One approach to develop self-adaptive behavior is to split the software into the domain and adaptation logic, which promotes separation of concerns. The domain logic implements the domain functionality for the end users, while the adaptation logic implements a feedback loop, like a monitor-analyze-plan-execute loop, that controls the runtime adaptation of the domain logic. Both logics are integrated by well-defined sensors and effectors. However, this separation usually requires a reflective runtime representation of the domain logic, which is used by the adaptation logic’s feedback loop. Such representations can be achieved by runtime models. Moreover, the feedback loop becomes a crucial part of the overall architecture.
In this context, we work on concepts for engineering self-adaptive software systems, esp. the adaptation logic, with runtime models. The Model-Driven Engineering (MDE) discipline is helpful though it is focused on the design, implementation, and deployment stages of software development. However, models and techniques following MDE principles can also be used at runtime for self-adaptation, which requires efficient on-line solutions. In general, we do research on the model-driven engineering of self-adaptive systems .
Particularly, we work on runtime models for feedback loops by means of models that are causally connected to the running system (these models reflect the running system with respect to different functional and non-functional concerns), that reflect the system’s environment, and that specify the adaptation steps (monitoring, analysis, planning, and execute). The interplay between these different models and thus feedback loops can be explicitly specified by so called megamodels. For this purpose, we proposed a specific modeling language and an interpreter to model and execute megamodels and thus feedback loops. Megamodels are kept explicit and alive at runtime, which leverages adaptive control architectures without having to integrate specific sensors or effectors in between feedback loops. In such architectures, feedback loops are organized in layers and a feedback loop at a higher level layer manages another feedback loop at a lower level layer. Thereby, a megamodel specifying a managed feedback loop directly serves as a reflection model used by the managing loop. All these efforts aim at engineering self-adaptive systems by bringing runtime models, feedback loops, and layered architectures together.
In this context, we also work on MDE techniques for feedback loops and employ graph transformation based techniques to maintain multiple runtime models or to analyze and change runtime models.