Scenario-driven development and runtime evolution of context-aware adaptive software systems

There is an increasing demand for software systems that have the ability to be adapted at runtime in response to changes in their environments and requirements. The changes can either be anticipated at the development time, or become known only when the systems in operation (i.e. unanticipated changes). Thus, such context-aware adaptive systems need to be developed with the adaptability in mind to cope with the anticipated changes, and to evolve in response to the unanticipated changes. To enable the development and runtime evolution of a context-aware adaptive system, a set of challenges need to be tackled. First, the system's functional and adaptation requirements and the context information required by the system for functional and adaptation use need to be explicitly specified in an easy-to-understand form. Second, the adaptation requirements of the system need to be checked for consistency to ensure that consistent adaptation actions are only applied to the system at runtime, and for validity to ensure that the application of these actions leads to valid system variants. Third, the system's executable model needs to have the ability to be adapted at runtime in response to anticipated and unanticipated changes. Fourth, to maintain a causal connection between the system's executable model and its requirements and to ease the task of designing the system, the executable (runtime) model of the system needs to be derived from its requirements automatically. In this thesis, we present a novel approach to assist the software engineer in the development and runtime evolution of context-aware adaptive systems. Our approach is scenario-driven, where the requirements for a context-aware adaptive system are specified as a set of scenarios. These scenarios are then automatically validated to ensure their consistency and validity. In addition, the system scenarios are used to derive the system's executable model for deployment. Furthermore, to cope with the unanticipated changes, the system scenarios are changed and their changes are then automatically reflected to the system while it is in operation. The approach makes four main contributions. First, it specifies the requirements for a context-aware adaptive software system as two sets of scenarios, i.e., functional and adaptation scenarios. These scenarios also identify contexts and their functional and adaptation use in the system. Second, the approach supports the automatic validation of the large number of system variants introduced by its high variability. It checks the consistency of the system's adaptation requirements, and identifies the system variants which are then generated and checked relative to system properties (that should hold at runtime) to ensure their validity. Third, we introduce an organization-based meta-model and adopt the models@runtime concept for keeping a contextii aware adaptive system's model (following the meta-model) alive at runtime. Thus, the system's executable (runtime) model can be easily adapted in response to anticipated and unanticipated changes. Fourth, to ease the task of designing the executable model of a system, we introduce a technique to derive the system's executable model from its requirements. In addition, to cope with unanticipated changes, we introduce a set of evolution patterns. These patterns are used to derive the changes to the system's runtime model from its changed scenarios (requirements). To demonstrate the applicability of our approach, we have used it to develop and evolve two case studies: a travel guide system and an electronic exam system. In addition, a feature-based analysis is performed to evaluate to what extent the approach meets the requirements that need to be considered in developing and evolving context-aware adaptive systems. Furthermore, a quantitative evaluation of the approach is carried out for: (1) assessing the reduction in the engineering effort gained when our approach is used for developing and evolving context-aware adaptive systems; (2) measuring the runtime cost of adding the adaptability feature to a software system; (3) quantifying the computational complexity for the algorithms (techniques) introduced in the approach. Overall, our novel scenario-driven approach assists the software engineer in specifying and validating the requirements of a context-aware adaptive system, and in designing, realizing, and evolving the system. In particular, it enables runtime changes to the software system in response to anticipated and unanticipated changes, and reduces the engineering effort needed to develop and evolve the system