A Framework for Evaluating Model-Driven Self-adaptive Software Systems

In the last few years, Model Driven Development (MDD), Component-based Software Development (CBSD), and context-oriented software have become interesting alternatives for the design and construction of self-adaptive software systems. In general, the ultimate goal of these technologies is to be able to reduce development costs and effort, while improving the modularity, flexibility, adaptability, and reliability of software systems. An analysis of these technologies shows them all to include the principle of the separation of concerns, and their further integration is a key factor to obtaining high-quality and self-adaptable software systems. Each technology identifies different concerns and deals with them separately in order to specify the design of the self-adaptive applications, and, at the same time, support software with adaptability and context-awareness. This research studies the development methodologies that employ the principles of model-driven development in building self-adaptive software systems. To this aim, this article proposes an evaluation framework for analysing and evaluating the features of model-driven approaches and their ability to support software with self-adaptability and dependability in highly dynamic contextual environment. Such evaluation framework can facilitate the software developers on selecting a development methodology that suits their software requirements and reduces the development effort of building self-adaptive software systems. This study highlights the major drawbacks of the propped model-driven approaches in the related works, and emphasise on considering the volatile aspects of self-adaptive software in the analysis, design and implementation phases of the development methodologies. In addition, we argue that the development methodologies should leave the selection of modelling languages and modelling tools to the software developers.Comment: model-driven architecture, COP, AOP, component composition, self-adaptive application, context oriented software developmen

Context Oriented Software Middleware

Our middleware approach, Context-Oriented Software Middleware (COSM), supports context-dependent software with self-adaptability and dependability in a mobile computing environment. The COSM-middleware is a generic and platform-independent adaptation engine, which performs a runtime composition of the software's context-dependent behaviours based on the execution contexts. Our middleware distinguishes between the context-dependent and context-independent functionality of software systems. This enables the COSM-middleware to adapt the application behaviour by composing a set of context-oriented components, that implement the context-dependent functionality of the software. Accordingly, the software dependability is achieved by considering the functionality of the COSM-middleware and the adaptation impact/costs. The COSM-middleware uses a dynamic policy-based engine to evaluate the adaptation outputs and verify the fitness of the adaptation output with the application's objectives, goals and the architecture quality attributes. These capabilities are demonstrated through an empirical evaluation of a case study implementation

PrimitiveC-ADL: Primitive Component Architecture Description Language

In this paper, we introduce an architecture descrip- tion language (ADL) for PCOMs (a context oriented component model). The language is described at three levels: (1) Building blocks (PCOMs context oriented components types) (2) Connec- tors, which connect components externally and internally, and (3) Architectural Configuration, which includes a full description of composition and decomposition mechanisms. The contribution is designing ADL. That supports context- orinted component by providing new architecture elements, which fulfil the requirements of designing context oriented component based applications. Context oriented component is a behavioural unit composed of static parts and dynamic parts. A PCOMs component model design was introduced in our previous work. PCOMs proposes a component model design to compose context-aware system by capturing context condition at runtime. The model is a component-based one that modifies the application architecture by subdividing components into subsystems of static and dynamic elements. We map each context condition to a composable template architectural configuration. Each context condition acts to select behavioural patterns, which combine to form application architectures. Different types of architecture elements are proposed in this work. We focus in defining the following new elements: Com- ponents’ dynamic and static parts, components’ layers, decision policies, and composition plan. Finally we introduce an ADL that fully supports context aware applications, by supporting the definition of a component as a unit of behaviour. Our ADL clearly defines the composition mechanisms, and provides proper definition for the composition’s design Patterns and composition plan. A Context oriented component is a behavioural unit composed with static parts and dynamic parts. A PCOMs component model design was introduced in our previous work. PCOMs proposes a component model design to compose context-aware system by capturing context condition at runtime. The model is a component-based one that modifies the application architecture by subdividing components into subsystems of static and dynamic elements. We map each context condition to a composable tem- plate architectural configuration. Each context condition acts to selected behavioural patterns, which combine to form application architectures

Deep Q Learning for Self Adaptive Distributed Microservices Architecture (in press)

One desired aspect of a self-adapting microservices architecture is the ability to continuously monitor the operational environment, detect and observe anomalous behavior, and provide a reasonable policy for self-scaling, self-healing, and self-tuning the computational resources in order to dynamically respond to a sudden change in its operational environment. The behaviour of a microservices architecture is continuously changing overtime, which makes it a challenging task to use a statistical model to identify both the normal and abnormal behaviour of the services running. The performance of the microservices cluster could fluctuate around the demand to accommodate scalability, orchestration and load balancing demands. To achieve the desired high levels of self-adaptability, this research implements microservices architectures model following the MAPE-K model. Our proposed architecture employs Markov decision process (MDP) to identify the transition from one cluster state to another. Our proposed architecture employs a deep Q- learning network (DQN) for dynamically selecting the adaptation action that yield the highest reward. This paper evaluates the effectiveness of using DQN and MDP agent to achieve high level of self-adaptability of microservice architecture. We argue in this paper that such integration between DQN and MDP in MAPE-K model offers microservice architecture with self-adaptability against the contextual changes in the operational environment. The self-adaptation property is achieved by allowing the MDP agent to explore the observation space and lets the DQN to select the adaptation policy with the highest reward, then the MDP agent executes the adaptation action and observes the changes. We believe integrating DQN into the adaptation action selection process improves the effectiveness of the adaptation and reduces the adaptation risk including resources over-provisioning and thrashing. The proposed model preserves the cluster state and preventing multiple actions to taking place at the same time. Our model also guarantees that the executed adaptation action fits the current execution context and achieves the adaptation goals

A Dynamic Rule-based Approach for Self-adaptive Map Personalisation Services

With continuous increase of available geographical information services, requirements for personalising map contentaccording to the user’s profile and context information areincreasingly important. Map personalisation applications could adapt their functionality/behaviour to provide the user with specific spatial data related to his interests at runtime. However, this can be achieved if map applications are able to filter and prioritise geospatial data using dynamic decision-making processes, whichconsiders users’ profiles and context for selecting and styling map content according to their needs. To this aim, this article proposes a new approach for map personalisation using dynamic rule-based engine, which provides the map application with the ability to change its styles and rules dynamically according to users’ profiles.This approach differs from the majority of existing works, which seek to embed the styling rules on the functional implementation of the map application. In addition, the personalisation engine is integrated with context-driven adaptation, which allows the application to monitor, detect, analyse, and react over changes onthe computational environment and users’ profiles. This enablesmap applications to use a styling rule that provides different levels of personalisation and adapt to changes in the computational environment including level of resources and quality of services

A Deep Recurrent Q Network Towards Self-adapting Distributed Microservices Architecture (in press)

One desired aspect of microservices architecture is the ability to self-adapt its own architecture and behaviour in response to changes in the operational environment. To achieve the desired high levels of self-adaptability, this research implements the distributed microservices architectures model, as informed by the MAPE-K model. The proposed architecture employs a multi adaptation agents supported by a centralised controller, that can observe the environment and execute a suitable adaptation action. The adaptation planning is managed by a deep recurrent Q-network (DRQN). It is argued that such integration between DRQN and MDP agents in a MAPE-K model offers distributed microservice architecture with self-adaptability and high levels of availability and scalability. Integrating DRQN into the adaptation process improves the effectiveness of the adaptation and reduces any adaptation risks, including resources over-provisioning and thrashing. The performance of DRQN is evaluated against deep Q-learning and policy gradient algorithms including: i) deep q-network (DQN), ii) dulling deep Q-network (DDQN), iii) a policy gradient neural network (PGNN), and iv) deep deterministic policy gradient (DDPG). The DRQN implementation in this paper manages to outperform the above mentioned algorithms in terms of total reward, less adaptation time, lower error rates, plus faster convergence and training times. We strongly believe that DRQN is more suitable for driving the adaptation in distributed services-oriented architecture and offers better performance than other dynamic decision-making algorithms

A Framework for Evaluating Model-Driven Self-adaptive Software Systems

In the last few years, Model Driven Development (MDD), Component-based Software Development (CBSD), and context-oriented software have become interesting alternatives for the design and construction of self-adaptive software systems. In general, the ultimate goal of these technologies is to be able to reduce development costs and effort, while improving the modularity, flexibility, adaptability, and reliability of software systems. An analysis of these technologies shows them all to include the principle of the separation of concerns, and their further integration is a key factor to obtaining high-quality and self-adaptable software systems. Each technology identifies different concerns and deals with them separately in order to specify the design of the self-adaptive applications, and, at the same time, support software with adaptability and context-awareness. This research studies the development methodologies that employ the principles of model-driven development in building self-adaptive software systems. To this aim, this article proposes an evaluation framework for analysing and evaluating the features of model-driven approaches and their ability to support software with self-adaptability and dependability in highly dynamic contextual environment. Such evaluation framework can facilitate the software developers on selecting a development methodology that suits their software requirements and reduces the development effort of building self-adaptive software systems. This study highlights the major drawbacks of the propped model-driven approaches in the related works, and emphasise on considering the volatile aspects of self-adaptive software in the analysis, design and implementation phases of the development methodologies. In addition, we argue that the development methodologies should leave the selection of modelling languages and modelling tools to the software developers

Productivity Evaluation of Self-Adaptive Software Model Driven Architecture

Anticipating context changes using a model-based approach requires a formal procedure for analysing and modelling context-dependent functionality and stable description of the architecture which supports dynamic decision-making and architecture evolution. This article demonstrates the capabilities of the context-oriented component-based application-model-driven architecture (COCA-MDA) to support the development of self- adaptive applications; the authors describe a state-of-the-art case study and evaluate the development effort involved in adopting the COCA-MDA in constructing the application. An intensive analysis of the applica- tion requirements simplified the process of modelling the application’s behavioural model; therefore, instead of modelling several variation models, the developers modelled an extra-functionality model. COCA-MDA reduces the development effort because it maintains a clear separation of concerns and employs a decom- position mechanism to produce a context-oriented component model which decouples the applications’ core functionality from the context-dependent functionality. Estimating the MDA approach’s productivity can help the software developers select the best MDA-based methodology from the available solutions. Thus, counting the source line of code is not adequate for evaluating the development effort of the MDA-based methodology. Quantifying the maintenance adjustment factor of the new, adapted, and reused code is a better estimate of the development effort of the MDA approaches

A deep recurrent Q network towards self-adapting distributed microservice architecture

One desired aspect of microservice architecture is the ability to self-adapt its own architecture and behavior in response to changes in the operational environment. To achieve the desired high levels of self-adaptability, this research implements distributed microservice architecture model running a swarm cluster, as informed by the Monitor, Analyze, Plan, and Execute over a shared Knowledge (MAPE-K) model. The proposed architecture employs multiadaptation agents supported by a centralized controller, which can observe the environment and execute a suitable adaptation action. The adaptation planning is managed by a deep recurrent Q-learning network (DRQN). It is argued that such integration between DRQN and Markov decision process (MDP) agents in a MAPE-K model offers distributed microservice architecture with self-adaptability and high levels of availability and scalability. Integrating DRQN into the adaptation process improves the effectiveness of the adaptation and reduces any adaptation risks, including resource overprovisioning and thrashing. The performance of DRQN is evaluated against deep Q-learning and policy gradient algorithms, including (1) a deep Q-learning network (DQN), (2) a dueling DQN (DDQN), (3) a policy gradient neural network, and (4) deep deterministic policy gradient. The DRQN implementation in this paper manages to outperform the aforementioned algorithms in terms of total reward, less adaptation time, lower error rates, plus faster convergence and training time. We strongly believe that DRQN is more suitable for driving the adaptation in distributed services-oriented architecture and offers better performance than other dynamic decision-making algorithms

Detecting the Onset of Dementia using Context-Oriented Architecture

In the last few years, Aspect Oriented Software De- velopment (AOSD) and Context Oriented Software Development (COSD) have become interesting alternatives for the design and construction of self-adaptive software systems. An analysis of these technologies shows them all to employ the principle of the separation of concerns, Model Driven Architecture (MDA) and Component-based Software Development (CBSD) for building high quality of software systems. In general, the ultimate goal of these technologies is to be able to reduce development costs and effort, while improving the adaptability, and dependability of software systems. COSD, has emerged as a generic devel- opment paradigm towards constructing self-adaptive software by integrating MDA with context-oriented component model. The self-adaptive applications are developed using a Context- Oriented Component-based Applications Model-Driven Architec- ture (COCA-MDA), which generates an Architecture Description language (ADL) presenting the architecture as a components- based software system. COCA-MDA enables the developers to modularise the application based on their context-dependent behaviours, and separate the context-dependent functionality from the context-free functionality of the application. In this article, we wish to study the impact of the decomposition mechanism performed in MDA approaches over the software self-adaptability. We argue that a better and significant advance in software modularity based on context information can increase software adaptability and increase their performance and modi- fiability