Dynamic Software Product Lines Research Articles

Variability Management in Self-Adaptive Systems through Deep Learning: A Dynamic Software Product Line Approach

Self-adaptive systems can autonomously adjust their behavior in response to environmental changes. Nowadays, not only can these systems be engineered individually, but they can also be conceived as members of a family based on the approach of dynamic software product lines. Through systematic mapping, we build on the identified gaps in the variability management of self-adaptive systems; we propose a framework that improves the adaptive capability of self-adaptive systems through feature model generation, variation point generation, the selection of a variation point, and runtime variability management using deep learning and the monitor–analysis–plan–execute–knowledge (MAPE-K) control loop. We compute the permutation of domain features and obtain all the possible variation points that a feature model can possess. After identifying variation points, we obtain an adaptation rule for each variation point of the corresponding product line through a two-stage training of an artificial neural network. To evaluate our proposal, we developed a test case in the context of an air quality-based activity recommender system, in which we generated 11 features and 32 possible variations. The results obtained with the proof of concept show that it is possible to manage identifying new variation points at runtime using deep learning. Future research will employ generating and building variation points using artificial intelligence techniques.

Providing command and control agility: A software product line approach

Command and Control (C2) is a broad concept that encompasses the coordination of individuals and organizations towards achieving a goal. However, dynamic and uncertain scenarios, such as military and disaster relief operations, present an inherent challenge to C2 activities. In such situations, plans often need to be changed in the face of unforeseen problems, and even coordination processes may be subject to variation. This dynamism increases the complexity of resource management and requires C2 Agility—i.e., the ability to respond to change in a timely and suitable fashion. Nonetheless, there is a lack of solutions to provide C2 Agility to cope with dynamic contexts. To address this problem, this work proposes a computational model of C2 Agility for a team of autonomous agents. This model describes how to combine reconfiguration of individual team members and of coordination approaches to adapt to context changes. The proposed approach leverages a typed-parameterized extension of a channel system to define the coordinating roles and responsibilities of team members. Each member is modeled as a dynamic software product line, with the inherent ability to reconfigure itself. To assess this model, a team of Unmanned Aerial Vehicles (UAV) performing a reconnaissance mission was simulated. The simulation showed that the proposed model was suitable for dealing with dynamic contexts. Particularly, metrics for the agile approach suggest improved system resilience in the face of induced perturbations, compared to non-agile C2. The obtained results with the proposed software-based simulations showed that the proposed model is useful in providing C2 Agility to the studied scenarios, making the behavior of the entities specified in the model capable of dealing with context changes.

Test scenario generation for feature-based context-oriented software systems

Feature-based context-oriented programming reconciles ideas from context-oriented programming, feature modelling and dynamic software product lines. It offers a programming language, architecture, tools and methodology to develop software systems consisting of contexts and features that can become active at run-time to offer the most appropriate behaviour depending on the actual context of use. Due to their high run-time adaptivity, dedicated tool support to test such systems is needed. Building upon a pairwise combinatorial interaction testing approach from the domain of software product lines, we implement an algorithm to generate automatically a small set of relevant test scenarios, ordered to minimise the number of context activations between tests. We also explore how the generated scenarios can be enhanced incrementally when the software evolves, and how useful the proposed testing approach is in practice.

Variability Management in Dynamic Software Product Lines for Self-Adaptive Systems—A Systematic Mapping

Context: Dynamic software product lines (DSPLs) have considerably increased their adoption for variability management for self-adaptive systems. The most widely used models for managing the variability of DSPLs are the MAPE-K control loop and context-aware feature models (CFMs). Aim: In this paper, we review and synthesize evidence of using variability constraint approaches, methodologies, and challenges for DSPL. Method: We conducted a systematic mapping, including three research questions. This study included 84 papers published from 2010 to 2021. Results: The main results show that open-dynamic variability shows a presence in 57.1% of the selected papers, and on the other hand, closed-dynamic variability appears in 38.1%. The most commonly used methodology for managing a DSPL environment is based on proprietary architectures (60.7%), where the use of CFMs predominates. For open-dynamic variability approaches, the MAPE-K control loop is mainly used. The main challenges in DSPL management are based on techniques (28.6%) and open variation (21.4%). Conclusions: Open-dynamic variability has prevailed over the years as the primary approach to managing variability in DSPL, where its primary methodology is the MAPE-K control loop. Response RQ3 requires further review.

A DSPL and Reinforcement Learning Approach for Context-Aware IoT Systems Development

The internet of things is a paradigm of interconnected devices able to communicate and exchange information to achieve users' requirements. In spite of their expansion in the last years, IoT systems still face challenges that hinder gaining major advantages from them. One of these challenges is to automatically adapt the system to the user's context and preferences. As a proposition to deal with this problem, this paper presents a methodology to design and develop IoT systems that adapt their behavior to their context, which can be a user or environmental context. This methodology is based on dynamic software product line engineering and uses Markov process to design the adaptation plan of the system and a reinforcement learning algorithm to implement it.

RuVa: A Runtime Software Variability Algorithm

Context-aware and smart systems that require runtime reconfiguration to cope with changes in the environment increasingly demand variability management mechanisms that can address runtime concerns. In recent years, we have witnessed new dynamic variability solutions using dynamic software product line (DSPL) approaches. However, while few solutions proposed so far have addressed the need to add, change and remove variants dynamically, none of them provide a way to check the constraints between features at runtime. Because all SAT solvers perform variability constraint checking in off-line mode, we suggest in this ongoing research paper the integration of RuVa, a runtime variability algorithm, with the FaMa tool suite to check feature constraints dynamically before a new feature is added or an existing feature is removed. This research suggests a novel approach to modifying the variability model of context-aware systems dynamically and check the feature constraints on the fly.We integrate our solution with a SAT solver that can be invoked at runtime by a cyber-physical system.We validate the effectiveness and performance of the proposed algorithm using simulations.We also provide a proof-of-concept for updating the configuration of a robot’s variability model based on contextual changes.

An adaptive IoT architecture using combination of concept-drift and dynamic software product line engineering

Internet of things (IoT) architecture needs to adapt autonomously to the environment and operational to maintain their supreme services. One common problem in the IoT architecture is to manage the reliability of data services, such as sensors’ data, that only sending data to the collector via gateway. If there is a disruption of services, then it is not easy to manage the system reliability. To this, an adaptive environment which is based on software reconfiguration creates a great challenge to provide better services. In this work, the software product line engineering (SPLE) reconfigures the edge devices via rules and software architecture. To identify disruption of data services which can be detected based on anomaly and truncated data. Our work makes use of concept drift to provide a recommendation to the system manager. This is important to avoid misconfiguration in the system We demonstrate our method using an open-source internet of things portal system that integrated to a cluster of sensors which is attached to specific gateway before the data are collected into a cloud storage for further processes. In identifying drifting data, the adaptive sliding window (ADWIN) method outperforms the Page-Hinkley (PH) with more selective identification and sensitive reading.

USING METHODS AND TECHNOLOGIES OF RECOMMENDATION SYSTEMS FOR DYNAMIC SOFTWARE PRODUCT LINES CONFIGURATION

Software product lines (SPL) dynamic configuring process could use methods for recommendation system (RS) elaboration. An overview and analysis of such methods was done in this paper. SPL represent a set of software systems that have common and variable functional components and use a set of paradigms and methods for development. In the classical static SPL the process of configuring performed before executing and performing in the operation environment (OE), in contrast dynamic software product lines performs after executing in the OE. Through the use of which it is possible to customize software solutions in accordance with the needs of end users. The following possible methods to build RS were considered: clustering, Markov decision-making process, matrix factorization. According to the review of the intelligent RS method development and researching of the functionalities of such systems in some open-source projects it was proposed to use N-dimensional context-dependent tensor factorization method and CARSkit tool system. Functional requirements and software architecture of the RS were developed. It allows to automatize software components configuration in the „Smart Home” (SH) systems that could be implemented with CARSkit software toolkit and algorithms implemented with programming language Python. This implementation allows to build a process for tracking changes in the external environment and transfer information to the SH system and, after analyzing the input data, process it in the RS to track changes in the context information. In the future research some additional quantitative experiments will be performed considering the specifics of the SH systems, additionally quantitative metrics will be used for efficiency assessment of the tensor factorization algorithms to predict the dynamic configurations of software components in these systems.
 Keywords: recommendation system, software product line, variability, dynamic configuration, architecture.

Survey Evaluation of an Approach for Dynamic Software Product Lines

In Dynamic Software Product Lines (DSPLs) product configuration occurs at runtime. Modelling variability and configuring the product in DSPLs should consider the context and non-functional requirements (NFRs) satisfaction. ConG4DaS (Contextual Goal models For Dynamic Software product lines) is a Requirements Engineering (RE) approach for DSPL which supports (i) modelling of variability with goals, NFRs, contexts and the relationship be-tween them; and (ii) offers a product configuration based on contexts, NFRs and their priority and interactions. In this paper, we present a survey evaluation of ConG4DaS with RE and DSPL researchers in regard to the perceived usefulness. In the survey, both RE and DSPL researchers perceived ConG4DaS as useful for modelling and configuring DSPLs. However, the RE group gave more positive answers than the DSPL group.

ProDSPL: Proactive Self-Adaptation based on Dynamic Software Product Lines

ProDSPL: Proactive Self-Adaptation based on Dynamic Software Product Lines

ProDSPL: Proactive self-adaptation based on Dynamic Software Product Lines

Dynamic Software Product Lines (DSPLs) are a well-accepted approach to self-adaptation at runtime. In the context of DSPLs, there are plenty of reactive approaches that apply countermeasures as soon as a context change happens. In this paper we propose a proactive approach, ProDSPL, that exploits an automatically learnt model of the system, anticipates future variations of the system and generates the best DSPL configuration that can lessen the negative impact of future events on the quality requirements of the system. Predicting the future fosters adaptations that are good for a longer time and therefore reduces the number of reconfigurations required, making the system more stable.ProDSPL formulates the problem of the generation of dynamic reconfigurations as a proactive controller over a prediction horizon, which includes a mapping of the valid configurations of the DSPL into linear constraints. Our approach is evaluated and compared with a reactive approach, DAGAME, also based on a DSPL, which uses a genetic algorithm to generate quasi-optimal feature model configurations at runtime. ProDSPL has been evaluated using a strategy mobile game and a set of randomly generated feature models. The evaluation shows that ProDSPL gives good results with regard to the quality of the configurations generated when it tries anticipate future events. Moreover, in doing so, ProDSPL enforces the system to make as few reconfigurations as possible.

Evolution in dynamic software product lines

AbstractMany software systems today provide support for adaptation and reconfiguration at runtime, in response to changes in their environment. Such adaptive systems are designed to run continuously and may not be shut down for reconfiguration or maintenance tasks. The variability of such systems has to be explicitly managed, together with mechanisms that control their runtime adaptation and reconfiguration. Dynamic software product lines (DSPLs) can help to achieve this. However, dealing with evolution is particularly challenging in a DSPL, as changes made at runtime can easily lead to inconsistencies. This paper describes the challenges of evolving DSPLs using an example cyber‐physical system for home automation. We discuss the shortcomings of existing work and present a reference architecture to support DSPL evolution. To demonstrate its feasibility and flexibility, we implemented the proposed reference architecture for two different DSPLs: the aforementioned cyber‐physical system, which uses feature models to describe its variability, and a runtime monitoring infrastructure, which is based on decision models. To assess the industrial applicability of our approach, we also implemented the reference architecture for a real‐world DSPL, an automation software system for injection molding machines. Our results provide evidence on the flexibility, performance, and industrial applicability of our approach.

A Context-Aware and Self-Adaptation Strategy for Cloud Service Selection and Configuration in Run-Time

Day after day, the number of mobile applications deployed on cloud computing continues in increasing because of smartphone capabilities improvement. Cloud computing has already succeeded in the web-based application, for that reason, the demand for context-aware services provided by cloud computing increases. To customize a cloud service that takes into account the consumer requirements, which depend on information change, it brings to light many recent challenges to cloud computing about environment-aware, location-aware, time-aware. The cloud provider, moreover, has to manage personalized applications and the constraints of mobile devices in matters of interaction abilities and communication restrictions. This paper proposes a strategy for selecting automatically an appropriate cloud environment that runs out whole requirements, defines a configuration for the associated cloud environment and able to easily adapt to the change of the environment on either the user or the cloud side or both. This process builds on the principles of dynamic software product lines, Agent-oriented software engineering, and the MAPE-k model to select and configure cloud environments according to the consumer needs and the context change.

Towards Adaptive Sensor-cloud for Internet of Things

The emerge of the Internet of Things (IoT) data as a commodity to optimize public services such as Fishing Locator has made sensor-cloud an important object. When sensors that are members of multiple IoT gateways can inter-operate at the same time for more than one application, it will reduce cost to deploy IoT infrastructure. However, reliability has also developed as the most important aspect for real-time data collection that should be streamed constantly. Due to uncertainty factors sensors failure is potentially occurred, then an adaptive approach should be addressed into this as to guarantee the flow of streaming data. This paper proposed an adaptive sensor-cloud mechanism to manage the reliability by using a runtime model approach where a transition model and dynamic software product line engineering will take place to weaving the system. Our technique is comparable to other approaches and can be implemented in many types of Cloud-based services.

Routing as a service (RaaS): An open framework for customizing routing services

With the emergence of various types of network applications, the user communication requirements for them are becoming more and more diversified and personalized. In order to accommodate the user frequently changing demands for different network applications, the Internet Service Provider (ISP) traditionally purchases and operates new dedicated network equipment, which always incurs high capital expense (CAPEX) and operating expense (OPEX) from the economic viewpoint and also burdens network management. Inspired by the ideas of Software Defined Networking (SDN) and Network Function Virtualization (NFV), we consider dealing with the above challenge by reusing virtualized network functions and selecting appropriate ones to compose the customized routing services on the routing paths for different applications. In this paper, based on SDN and NFV, we propose Routing as a Service (RaaS) as an open framework to customize the specific routing services for applications. Then, we present Routing Service Product Line (RSPL) by introducing Dynamic Software Product Line (DSPL) into the proposed RaaS, so as to rapidly customize a large number of routing services with different characteristics. In addition, according to the proposed framework, we also carry out a case study to customizing routing services with benefits of both the user and the ISP considered. Simulation results show that the proposed RaaS is feasible and efficient.

Context-aware energy-efficient applications for cyber-physical systems

Software systems have a strong impact on the energy consumption of the hardware they use. This is especially important for cyber-physical systems where power consumption strongly influences the battery life. For this reason, software developers should be more aware of the energy consumed by their systems. Moreover, software systems should be developed to adapt their behavior to minimize the energy consumed during their execution. This can be done by monitoring the usage context of the system and having runtime support to react to those changes that impact the energy footprint negatively. Although both the hardware and the software parts of cyber-physical systems can be adapted to reduce its energy consumption, this paper focuses on software adaptation. Concretely, the paper illustrates how to address the problem of developing context-aware energy-efficient applications using a Green Eco-Assistant that makes use of advanced software engineering methods, such as Dynamic Software Product Lines and Separation of Concerns. The main steps of our approach are illustrated by applying them to a cyber-physical system case study.

A UI-DSPL Approach for the Development of Context-Adaptable User Interfaces

Unlike adaptive interfaces which use sensors to adapt themselves, adaptable interfaces need the intervention of end users to adapt their different aspects according to user requirements. These requirements are commonly expressed according to the context of use. This latter was defined by the triplet where the platform refers to the physical device and the device software, the environment refers to the physical environment in which the application is used and the user element refers to the user preferences and user profile. In this paper, we define a dynamic software product line (DSPL) approach for the development of a family of context-adaptable user interfaces. The DSPL paradigm exploits the knowledge acquired in software product line engineering to develop systems that can be context-aware, or runtime adaptable. Our approach satisfies a set of contributions which will be validated by implementing and evaluating them according to an illustrative case study.

Context‐dependent reconfiguration of autonomous vehicles in mixed traffic

AbstractHuman drivers naturally adapt their behaviour depending on the traffic conditions, such as the current weather and road type. Autonomous vehicles need to do the same, in a way that is both safe and efficient in traffic composed of both conventional and autonomous vehicles. In this paper, we demonstrate the applicability of a reconfigurable vehicle controller agent for autonomous vehicles that adapts the parameters of a used car‐following model at runtime, so as to maintain a high degree of traffic quality (efficiency and safety) under different weather conditions. We follow a dynamic software product line approach to model the variability of the car‐following model parameters, context changes and traffic quality, and generate specific configurations for each particular context. Under realistic conditions, autonomous vehicles have only a very local knowledge of other vehicles' variables. We investigate a distributed model predictive controller agent for autonomous vehicles to estimate their behavioural parameters at runtime, based on their available knowledge of the system. We show that autonomous vehicles with the proposed reconfigurable controller agent lead to behaviour similar to that achieved by human drivers, depending on the context.

On the implementation of dynamic software product lines: An exploratory study

Abstract Dynamic Software Product Line (DSPL) engineering is a paradigm aimed at handling adaptations at runtime. An inherent challenge in DSPL engineering is to reduce the design complexity of adaptable software, particularly in terms of evolution. Existing research only recently started to investigate evolution in this field, but does not assess the impact of different implementations under software quality in evolutionary scenarios. This work presents a characterization of thirteen dynamic variability mechanisms. Based on such characterization, we implemented a DSPL using Object-oriented Programming (OOP) mechanisms. From this implementation, we evidenced that DSPL requires changes and extensions to design, in terms of functionality and adaptation capabilities. Since Aspect-oriented Programming (AOP) was well ranked according to characterization and some studies have demonstrated the likely synergies between AOP and DSPL, we decided to compare it with OOP. We empirically evaluated how OOP and AOP could affect source code quality from the viewpoint of an evolving DSPL. As a result, AOP yields better results in terms of size, SoC, cohesion, and coupling measures. Conversely, AOP provides lower change propagation impact. Although the packages in AOP were more susceptible to changes than in OOP, we could indicate that AOP may be a feasible strategy for DSPL implementation.

Dynamic Software Product Line Engineering: A Reference Framework

Runtime adaptive systems are able to dynamically transform their internal structure, and hence their behavior, in response to internal or external changes. Such transformations provide the basis for new functionalities or improvements of the non-functional properties that match operational requirements and standards. Software Product Line Engineering (SPLE) has introduced several models and mechanisms for variability modeling and management. Dynamic software product lines (DSPL) engineering exploits the knowledge acquired in SPLE to develop systems that can be context-aware, post-deployment reconfigurable, or runtime adaptive. This paper focuses on DSPL engineering approaches for developing runtime adaptive systems and proposes a framework for classifying and comparing these approaches from two distinct perspectives: adaptation properties and adaptation realization. These two perspectives are linked together by a series of guidelines that help to select a suitable adaptation realization approach based on desired adaptation types.