A Quality-Driven Approach to Enable Decision-Making in Self-Adaptive Software

Self-adaptive software systems are increasingly in demand. The driving forces are changes in the software “self” and “context”, particularly in distributed and pervasive applications. These systems provide self-* properties in order to keep requirements satisfied in different situations. Engineering self-adaptive software normally involves building the adaptable software and the adaptation manager. This PhD thesis focuses on the latter, especially on the design and implementation of the deciding process in an adaptation manager. For this purpose, a Quality-driven Framework for Engineering an Adaptation Manager (QFeam) is proposed, in which quality requirements play a key role as adaptation goals. Two major phases of QFeam are building the runtime adaptation model and designing the adaptation mechanism. The modeling phase investigates eliciting and specifying key entities of the adaptation problem space including goals, attributes, and actions. Three composition patterns are discussed to link these entities to build the adaptation model, namely: goal-centric, attribute-action-coupling, and hybrid patterns. In the second phase, the adaptation mechanism is designed according to the adopted pattern in the model. Therefore, three categories of mechanisms are discussed, in which the novel goal-ensemble mechanism is introduced. A concrete model and mechanism, the Goal-Attribute-Action Model (GAAM), is proposed based on the goal-centric pattern and the goal-ensemble mechanism. GAAM is implemented based on the StarMX framework for Java-based systems. Several considerations are taken into account in QFeam: i) the separation of adaptation knowledge from application knowledge, ii) highlighting the role of adaptation goals, and iii) modularity and reusability. Among these, emphasizing goals is the tenet of QFeam, especially in order to address the challenge of addressing several self- * properties in the adaptation manager. Furthermore, QFeam aims at embedding a model in the adaptation manager, particularly in the goal-centric and hybrid patterns. The proposed framework focuses on mission-critical systems including enterprise and service-oriented applications. Several empirical studies were conducted to put QFeam into practice, and also evaluate GAAM in comparison with other adaptation models and mechanisms. Three case studies were selected for this purpose: the TPC-W bookstore application, a news application, and the CC2 VoIP call controller. Several research questions were set for each case study, and findings indicate that the goal-ensemble mechanism and GAAM can outperform or work as well as a common rule-based approach. The notable difference is that the effort of building an adaptation manager based on a goal-centric pattern is less than building it using an attribute-action-coupling pattern. Moreover, representing goals explicitly leads to better scalability and understandability of the adaptation manager. Overall, the experience of working on these three systems show that QFeam improves the design and development process of the adaptation manager, particularly by highlighting the role of adaptation goals

Separating Agent-Functioning and Inter-Agent Coordination by Activated Modules: The DECOMAS Architecture

The embedding of self-organizing inter-agent processes in distributed software applications enables the decentralized coordination system elements, solely based on concerted, localized interactions. The separation and encapsulation of the activities that are conceptually related to the coordination, is a crucial concern for systematic development practices in order to prepare the reuse and systematic integration of coordination processes in software systems. Here, we discuss a programming model that is based on the externalization of processes prescriptions and their embedding in Multi-Agent Systems (MAS). One fundamental design concern for a corresponding execution middleware is the minimal-invasive augmentation of the activities that affect coordination. This design challenge is approached by the activation of agent modules. Modules are converted to software elements that reason about and modify their host agent. We discuss and formalize this extension within the context of a generic coordination architecture and exemplify the proposed programming model with the decentralized management of (web) service infrastructures

A metric-based heuristic framework to detect object-oriented design flaws

Abstract One of the important activities in re

L.: ’Architectural Recovery of JBoss Application Server

Abstract This report addresses analysis of the architecture of an object-oriented system written in Java -JBoss Application Server. By selecting this case study, we follow two major objectives. First, we want to use object-oriented entities as building blocks of software architecture. Second, due to success of JBoss as an open source J2EE platform in the market and among developers, and its high modular and scalable design, it is an apt case study for Software Architectural Recovery. In a nutshell, we aim to make a bridge from object-oriented system hierarchy and its design rules to generic building blocks, relations, and architectural rules in JBoss Application Server. We propose how a subset of object-oriented design rules is able to evaluate architecture of a software system in terms of maintainability and reusability. We also propose a set of hypothesis describing a lightweight methodology to express the architectural flaws of JBoss system based on source code analysis approach

Towards a goal-driven approach to action selection in self-adaptive software

Self-adaptive software is a closed-loop system, since it continuously monitors its context (i.e. environment) and/or self (i.e. software entities) in order to adapt itself properly to changes. We believe that representing adaptation goals explicitly and tracing them at run time are helpful in decision-making for adaptation. While goal-driven models are used in requirements engineering, they have not been utilized systematically yet for run-time adaptation. To address this research gap, this article focuses on the deciding process in selfadaptive software, and proposes the Goal-Action-Attribute Model (GAAM). An action selection mechanism, based on cooperative decision-making, is also proposed, which uses GAAM to select the appropriate adaptation action(s). The emphasis is on building a light-weight and scalable run-time model which needs less design and tuning effort comparing with a typical rule-based approach. TheGAAMand action selection mechanism are evaluated using a set of experiments on a simulated multi-tier enterprise application, and two sample ordinal and cardinal preference lists. The evaluation is accomplished based on a systematic design of experiment and a detailed statistical analysis with ANOVA in order to investigate several research questions. The findings are promising, considering the obtained results, and other impacts of the approach on engineering self-adaptive software. Although, one case study is not enough to generalize the findings, and the proposed mechanism does not always outperform a typical rule-based approach, less effort, scalability and flexibility of GAAM are remarkable

Towards model-centric engineering of a dynamic access control product line

Access control systems are deployed in organizations to protect critical cyber-physical assets. These systems need to be adjustable to cope with di erent contextual factors like changes in resources or requirements. Still, adaptation is often performed manually. In addition, di erent product variants of access control systems need to developed together systematically. These characteristics demand a product line engineering approach for enhanced reuse. Moreover, to cope with uncertainty at runtime, adaptivity, i.e., switching between variations in a cyber-physical domain (recon guration) and adjusting access policies (behavior adaptation), needs to be supported. In this position paper, we sketch an approach for engineering dynamic access control systems based on core concepts from dynamic software product lines and executable runtime models. The proposed solution is presented and rst experiences are discussed along a sample dynamic software product line in the role-based access control domain