Smart Application Grids – SMAGs
With the advent and wide-spread acceptance of mobile devices, an ever-growing range of intelligent devices and their ability to communicate over a common infrastructure, the requirements for traditional software engineering changed radically. Software has become the central aspect of both personal and professional life and is omnipresent. Usually, we use the same mobile (e.g., smartphone) or immobile (e.g., home automation) software-intensive devices in varying situations, different tasks and changing contexts. Thus, the behavior of the devices and the corresponding software must be adapted to the changing requirements at runtime. The ability of a software system to adjust their behavior to changing contexts is called self-adaptiveness. A self-adaptive system (SAS) is based on a variant of the MAPE-K feedback loop, where environmental variables are monitored (M) and analyzed (A). Afterwards, the current state of the system is evaluated w.r.t. the analyzed state of the world and reconfiguration plans are derived (P) and executed (E). The model capturing the environmental and system-specific information is called knowledge base (K). Implementing this feedback-loop by hand leads to scattering and tangling of the adaptation logic. In consequence, the maintainability and the reusability of the application blocks and the entire software system is decreased tremendously. Furthermore, this approach leads to a huge set of incompatible, application-specific adaptation mechanisms. On top of this, in cases where developers cannot foresee all contextual situations, leading to adaptation at design-time, approaches for unanticipated adaptation are needed. To deal with this problem, researchers proposed different approaches to treat context-additivity as a first-class-citizen of the entire software engineering process.
This thesis presents a design, development and execution approach for distributed connected self-adaptive systems combining role-based and component-based software engineering “Smart Application Grids” (SMAGs). SMAGs uses model-driven software development to define component-based systems on an architectural level, wherein roles are integrated as a design and implementation concept. Roles can be played by component objects, dynamically extending their type and thus, extend and change their state and behavior during runtime. Furthermore, roles describe varying relationships between objects. This concept is used to model dynamically varying relationships between objects within one or among many applications. SMAGs has a platform-independent and a platform-specific modeling dimension. Thus, the concept is independent of the individual programing language and runtime environment. However, a dedicated implementation of the SMAGs runtime environment and a corresponding code-generator is necessary each specific platform. The SMAGs runtime environment provides an infrastructure and base-implementations for the MAPE-K feedback loop, which is bootstrapped with the same implementation technique. Thus, the runtime environment is itself self-adaptive, enabling meta-adaptation. Meta-adaptation paves the way to dynamically adjust the adaptation logic itself and builds the foundation for unanticipated adaptation. SMAGs currently is used and evaluated as the implementation technology of various demonstrators and research projects, ranging from mobile interactive systems to industrial robots.