Taking a Glimpse at Reengineering Challenges in Evolution Towards 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 between 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 his study presents the report about a case study on the application of REACT-M (Requirements Evolution in Agile ContexT - Management), an agile method to support software requirements management, in a real software development environment. This case study assessed the strengths, weaknesses, opportunities, and threats related to the assets that make up REACT-M, namely: work products, life cycle, roles, and ceremonies. About the results, it was observed that REACT-M was effective, simple to use, strongly collaborative, suitable, user centered and goal oriented. Thus, achieved its main purpose to evolve the requirements of a software product in iteratively, efficiently and under of the agile mindset. The results contribute to the software industry by providing empirical data about the use of a agile method to software requirements management, which can serve as a reference for organizations seeking the adoption of agile methods related to the requirements area, as well as to provide the scientific community with a better empirical understanding of the relationship between requirements and agile methodDSPL group.

We envision an Autonomic Software Product Line (ASPL). The ASPL is a dynamic software product line that supports self adaptable products. We plan to use reflective architecture to model and develop ASPL. To evaluate the approach, we have implemented three autonomic product lines which show promising results. The ASPL approach is at initial stages, and require additional work. We plan to exploit online learning to realize more dynamic software product lines to cope with the problem of product line evolution. We propose on-line knowledge sharing among products in a product line to achieve continuous improvement of quality in product line products.

Emerging domains such as smart homes and more recently smart cities represent a big challenge to software engineering. In such context, the need of runtime self-adaptations to cope with both user needs and environmental changes brings Dynamic Software Product Lines (DSPL) as a suitable solution. However, DSPL implementation itself is challenging, which demands a proper modeling. In this sense, the literature still lacks of means of choosing the modeling technique that best fits a given domain. This paper tackles such problem by defining a criteria for rank such techniques, which is used for ranking a set DSPL modeling techniques found in the literature.

BackgroundThe software product lines (SPL) enable development teams to fully address a systematic reuse of shared assets to deliver a family of similar software products. Mobile applications are an obvious candidate for employing an SPL approach. This paper presents our research outcomes, based on empirical data from an industry-level development project. Two development teams were confronted with the same functionalities set to be delivered through a family of native mobile applications for Android and iOS.MethodsEmpirical data was gathered before, during and after a year of full-time development. The data demonstrate the impact of a SPL approach by comparing the SPL and non-SPL multiple edition development. One family of products (Android apps) was developed using an SPL approach, while another (iOS apps), functionally the same, was developed without employing an SPL approach. The project generated a volume of raw and aggregated empirical data to support our research questions.ResultsThe paper reports a positive impact of an SPL approach on product quality (internal and external) and feature output per week. As data shows, it also increases the delivery of functionalities (240% in 6 more editions), while investing the same amount of effort needed for a single-edition development. As a result of system-supported separation of development and production code, developers had a high confidence in further development. On the other hand, the second team delivered less new functionalities, only two new application editions, and lower software quality than the team that manages multi-edition development by employing an SPL approach.

NASA is developing plans for innovative and novel approaches to future (unmanned) space exploration missions. Future missions involve sending spacecraft and robots to harsh environments, where resilience is necessary for the survival of the mission. In addition, distances and communication lead times between the spacecraft and Earth necessitate much of the mission operation being autonomous. We have been conducting research on the development of autonomous space exploration missions based on principles from Autonomic Computing (AC), whereby the mission is imbued with self-management capabilities. Such missions will involve several, rather than single, spacecraft, robots or other devices, operating in collaboration. We describe one such concept mission, ANTS (Autonomous Nano-Technology Swarm), which involves a number of sub-missions that are self-similar. Our work in this, and other future missions, has involved the use of techniques from AC for building in self-management, and ultimately self-governance. We have also explored the use of formal methods to gain confidence in the correct behavior of the mission. Since both the physical devices which will be used for exploration, and the software that is essential for their successful deployment, lend themselves to a product-line approach, we have been exploiting techniques from software product-line engineering, in particular Multi-Agent System Product Lines (MAS-PL) and Dynamic Software Product Lines (DSPL).

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

Dynamic Software Product Line (DSPL) Engineering has gained interest through its promise of being able to unify software adaptation whereby software adaptation can be realised at compile time and runtime. While previous work has enabled program logic adaptation by the use of language extensions and platform support, little attention has been placed on Graphical User Interface (GUI) variability. Different design patterns including the Model View Controller are commonly used in GUI implementation, with GUI documents being used for declaring the GUI. To handle dynamic GUI variability currently, the developer needs to implement GUI refinements using multiple techniques. This paper proposes a solution for dealing with GUI document variability, statically and dynamically, in a unified way. In our approach, we currently use a compile time method for producing GUI variants, and code transformations to handle these variants within the application at runtime. To avoid GUI duplicates, only GUI variants that are unique, and related to a valid product configuration, are produced. To validate our approach, we implemented tool support to enable this for Android based applications.

Due to the very large number of configurations that can typically be derived from a Dynamic Software Product Line (DSPL), efficient and effective testing of such systems have become a major challenge for software developers. In particular, when a configuration needs to be deployed quickly due to rapid contextual changes (e.g., in an unfolding crisis), time constraints hinder the proper testing of such a configuration. In this paper, we propose to reduce the testing required of such DSPLs to a relevant subset of configurations. Whenever a need to adapt to an untested configuration is encountered, our approach determines the most similar tested configuration and reuses its test results to either obtain a coverage measure or infer a confidence degree for the new, untested configuration. We focus on providing these techniques for inference of structural testing results for DSPLs, which is supported by an early prototype implementation.

Nowadays, more than one billion people are in need of one or more assistive technologies, and this number is expected to increase beyond two billion by 2050. The majority of assistive technologies are supported by battery-operated devices like smartphones and wearables. This means that battery weight is an important concern in such assistive devices because it may affect negatively its ergonomics. Saving power in these assistive devices is of utmost importance for its potential twofold benefits: extend the device life and reduce the global warming aggravated by billion of these devices. Dynamic Software Product Lines (DSPLs) are a suitable technology that supports system adaptation, in this case, to reduce energy consumption at runtime, considering contextual information and the current state of the device. However, a reduction in battery consumption could negatively affect other quality of service parameters, like response time. Therefore, it is important to trade-off battery saving and these other concerns. This work illustrates how to approach the self-adaptation of smart assistive devices by means of a DSPL-based strategy that optimizes battery consumption taking into account other QoS parameters at the same time. We illustrate our proposal with a real case study: a Smart Cane that is integrated with a DSPL platform, Tanit. Experimentation shows that it is possible to make a trade-off between different quality concerns (energy consumption and relative error). The results of the experiments allow us to conclude that the Tanit approach elongates battery duration of the Smart Cane in one day (an increase of a 6% with a relative error of 1%), so we improve the user quality of experience and reduce the energy footprint with a reasonable relative error.

Software product family or line is a software engineering paradigm that systematizes reuse. In software product line engineering, two phases are distinguished: domain engineering which is in charge of developing a common infrastructure and assets and application engineering which makes use of those assets to generate the products. One of the key aspects of product lines is variability and its management. However, the main focus has been on functional variability and quality variability in software product lines has not received so much attention by researchers. In a product line different members of the line may require different levels of a quality requirement, for instance they could differ in terms of their availability, security, reliability, etc. Due to this variability, quality evaluation in software product lines is much more complicated that in single-systems. One alternative is to evaluate all the products of a line but it is very expensive and ways of reducing evaluation efforts are necessary. In this direction, the paper presents a method for facilitating cost-effective quality evaluation of a product line taking into consideration variability on quality attributes.

Today's adaptive software systems (i) are often highly configurable product lines, exhibiting hundreds of potentially conflicting configuration options; (ii) are context dependent, forcing the system to reconfigure to ever-changing contextual situations at runtime; (iii) need to fulfill context-dependent performance goals by optimizing measurable nonfunctional properties. Usually, a large number of consistent configurations exists for a given context, and each consistent configuration may perform differently with regard to the current context and performance goal(s). Therefore, it is crucial to consider nonfunctional properties for identifying an appropriate configuration. Existing black-box approaches for estimating the performance of configurations provide no means for determining context-sensitive reconfiguration decisions at runtime that are both consistent and optimal, and hardly allow for combining multiple context-dependent quality goals. In this paper, we propose a comprehensive approach based on Dynamic Software Product Lines (DSPL) for obtaining consistent and optimal reconfiguration decisions. We use training data obtained from simulations to learn performance-influence models. A novel integrated runtime representation captures both consistency properties and the learned performance-influence models. Our solution provides the flexibility to define multiple context-dependent performance goals. We have implemented our approach as a standalone component. Based on an Internet-of-Things case study using adaptive wireless sensor networks, we evaluate our approach with regard to effectiveness, efficiency, and applicability.

Cloud-based technologies play an increasing role in software engineering because of their scalability, availability, and cost efficiency. However, due to privacy issues, developers and organizations still hesitate to host applications that handle sensitive data on servers of external cloud providers. Modern hardware extensions, such as Intel's Software Guard Extensions (SGX), are an attempt to provide confidentiality and integrity for applications running on external hardware. Still, enabling SGX in cloud systems poses new challenges considering scalability and flexibility. In this paper, we propose an approach to address these issues by employing concepts from the domain of Dynamic Software Product Lines (DSPLs). We aim to enable applications running on SGX-based cloud systems to be securely reconfigurable and extendable during runtime. In particular, we describe properties that such an approach should fulfill and discuss corresponding challenges.

Variability management is crucial for companies that need to offer multiple product variants quickly. However, the increasing complexity of software-intensive systems has made variability management increasingly challenging. This challenge is compounded by the need for such systems to run continuously and adapt to changes in the environment and user needs at runtime. To address this challenge, Dynamic Software Product Line (DSPL) Engineering has emerged as a strategy for managing variability in complex and dynamic environments. The key challenge in DSPL engineering is to manage product configurations at runtime by detecting changes in the context and adapting accordingly. In this paper, we propose an adaptation mechanism for DSPL feature models that supports dynamic variability and is based on the MAPE-K model. The mechanism transforms feature model constraints into rules that enable the activation of each feature and annotates contexts in the corresponding features to be activated when changes occur. We have implemented the mechanism in the DyMMer 2.0 modeling tool and evaluated its performance using various DSPL feature models. Additionally, we performed a preliminary evaluation with a proof-of-concept study with an expert to assess its practical usage. Our results demonstrate the effectiveness and practicality of the proposed mechanism in managing variability in complex and dynamic environments.

Service robot has its challenge to adapt on new tasks based on instruction or environment. Such conditions need to reconfigure or reorganize to obtain new system capabilities. However, most common service robot, especially the one that gives services to help human to deliver food or non medical stuffs in an elderly house, suffers on its task flexibility. Unlike a human, robot system needs to be reconfigured to have a new task which may interrupt its services because of this event. To this, we need a technique to handle adaptive tasks that is flexible to change the robot tasks that do not create delay. Dynamic software product line provides a mechanism to reconfigure a system to have different capabilities based on the core assets of the system, such as software that supports and controls the hardware components in a robotic system. In this work, we make use of the dynamic software product line to create a flexible method that enables a service robot to adapt on its new tasks. In order to define the change of tasks, we model the transformation of task using a transition state which has constraints as a trigger. Other than that, the request of change may also have resulted by forcing an interrupt mechanism. To demonstrate the capability of our approach, the proof of concept using Robotic Operating System will be presented.

Software product lines enable reuse of shared software across a family of products. As new products are built in the product line, new features are added. The features are units of functionality that provide services to users. Unwanted feature interactions, wherein one feature interferes with another feature’s operation, is a significant problem, especially as large software product lines evolve. Detecting feature interactions is a time-consuming and difficult task for developers. Moreover, feature interactions are often only discovered during testing, at which point costly re-work is needed. This paper proposes a similarity-based method to identify unwanted feature interactions much earlier in the development process. It uses knowledge of prior feature interactions stored with the software product line’s feature model to help find unwanted interactions between a new feature and existing features. The paper describes the framework and algorithms used to detect the feature interactions using three path similarity measures and evaluates the approach on a real-world, evolving software product line. Results show that the approach performs well, with 83% accuracy and 60% to 100% coverage of feature interactions in experiments, and scales to a large number of features.