75

97

Software is frequently developed in many similar copies, called forks or cloned software variants. During this development, pairwise comparison is routinely used for finding differences between the cloned copies, assessing their similarity, and merging the content. However, analyzing the similarity of a large group of variants using pairwise comparison is a relatively difficult task, as the number of compared pairs grows quadratically with the number of variants. Furthermore, the result of such group of pairwise comparisons is difficult to visualize. In this paper, we discuss the problem of N-way comparison of cloned software variants. We represent the N-way comparison result as a model of N intersecting sets. By aggregating the sets along the system decomposition hierarchy, we construct the sets at every level of the system structure (files, folders, and whole systems). We define a generalized approach for set model construction, and instantiate it for an N-way diff on the textual code representation. We propose set-based visualizations for the N-way comparison, which scale for more than ten component variants and MLOC-sized components. We evaluate the approach by applying it to several groups of industrial software system variants and by performing a controlled experiment with a comparison of 5 software forks. In the experiment, the group using set-based comparison solved the tasks in 58% less time and with 92% fewer incorrect answers than the group using pairwise comparison. Finally, we propose a generalization of the approach beyond software, to enable set-based comparison and similarity visualization for hierarchically structured models and data, for example genomes.

Product line engineering (PLE) approaches have been followed in industry for hardware and software solutions for more than three decades now. However, the different engineering disciplines (e.g. mechanics, electrics, software) have developed and evolved their approaches within their own realms, which is fine as long as there is no need for integrated approaches. Driven by the increasing complexity of systems, there is a rising need for interdisciplinary systems engineering these days. Companies engineering cyber-physical systems and their components have to integrate product line engineering approaches across the involved engineering disciplines to enable a global optimization of portfolio, solution structures, and assets along their lifecycle. From a bird's-eye view, there is noticeable commonality but also variety in the approaches followed for PLE in the different engineering disciplines, which renders the integration of approaches a non-trivial endeavour. In order to foster the development of integrated PLE approaches, this paper explores, maps, and compares PLE approaches in the field of hardware and software engineering. Furthermore, the paper identifies integration opportunities and challenges. As the paper targets industrial practitioners, it mainly provides references to respective industrial events and material and does not fully cover related work in the respective research communities.

The study presented in this paper aims to provide evidence for the hypothesis that software product line research has been changing and that the works in industry and academia have diverged over time. We analysed a subset (140) of all (593) papers published at the Software Product Line Conference (SPLC) until 2017. The subset was randomly selected to cover all years as well as types of papers. We assessed the research type of the papers (academic or industry), the kind of evaluation (application example, empirical, etc.), and the application domain. Also, we assessed which product line life-cycle phases, development practices, and topics the papers address. We present an analysis of the topics covered by academic vs. industry research and discuss the evolution of these topics and their relation over the years. We also discuss implications for researchers and practitioners. We conclude that even though several topics have received more attention than others, academic and industry research on software product lines are actually rather in line with each other.

In order to derive executable software artefacts, the build system needs to be maintained properly along with the evolution of source code. However, in large software projects the building process often becomes effort-consuming, and sometimes the building process contains defects or even fails. To cope with these challenges, the first step is to understand the build process. In this paper, we take Android as the example system, and propose an automated approach to analyzing the Android build dependency structure (including extraction of building jobs, related artefacts, duration, etc.). Moreover, the analysis results of Android 5 and 6 are compared in order to identify build differences between these two releases. The extracted build dependencies and comparison results are also visualized with tool support. As the analysis approach and tools are not limited to Android, it can be also used for extracting the build dependency structure of other systems.

Software and systems product line engineering (PLE) has been an established approach for reducing time to market as well as cost and increasing quality in a set of related products for two decades now. Although there is a huge body of knowledge on PLE, adopting a concrete PLE approach is still not a trivial endeavor for interested companies. With the increasing importance of development speed, the advent of agile engineering approaches, and decreasing management interest in improvements that require large organizational transformations and only show benefits after several years, companies are facing challenges in successfully adopting this approach. They often hesitate as there is no clear adoption path, nor any certainty, that the intended improvement steps will also provide added value in the short- and mid-term perspective. In consequence, a considerable amount of PLE potential still remains unexploited.

Nowadays systems are often developed following the product line approach in order to reduce time to market, achieve lower cost, and ensure high quality. To this end, common and variable requirements of product variants are specified as features in a feature model, so that each product variant can be configured and customized along the development lifecycle. While developers in family engineering tend to use variability management tools (e.g., pure::variants) for feature modeling and developing core assets for reuse, such sophisticated tools might be too complicated and inappropriate for product configuration in application engineering. In order to solve this challenge, this paper introduces an Excel-based product configurator called EXConfig, which focuses on product line features in the problem space and supports staged product configuration in application engineering. This tool can be easily customized and integrated with other system design tools or variability management tools, which connects application engineering and family engineering in development. The usage of this tool and its integration have been validated several times in industry.

Managing product variants and versions in an integrated way, e.g. to cope with the inherent complexity of product or solution portfolios, to reduce time to market, or to provide a coherent user experience to end users, is an ever increasing engineering challenge and competition factor in all business segments. Various engineering approaches including cloning, product or component platforms, product lines, production lines, and configurable systems are followed in practice to cope with the product variation in space and time. Unfortunately, there is no silver-bullet approach, and companies have to choose and adopt respective approaches in a deliberate way, but there is often only limited understanding of how to do so. Adoption problems, unexploited potential, wasted investments, frustration and disapproval are typical symptoms, which can be seen in consequence in the wild.

The notion of features is commonly used to describe the functional and non-functional characteristics of a system. In software product line engineering, features often become the prime entities of software reuse and are used to distinguish the individual products of a product line. Properly decomposing a product line into features, and correctly using features in all engineering phases, is core to the immediate and long-term success of such a system. Yet, although more than ten different definitions of the term feature exist, it is still a very abstract concept. Definitions lack concrete guidelines on how to use the notion of features in practice.

Software and System Product Lines (SSPL) are the state-of-the-art for systematically reusing a common set of core assets in the development of similar products in a product family. A large number of SSPL success stories have been published in the last decade and commercial tool support is also available. SSPLs promise to reduce cost, to shorten time-to-market for new features, and to increase product quality by systematically reusing core assets in the development of three or more systems. However, an open challenge is SSPL engineering for safety-relevant systems such as automotive, avionic, or industrial automation systems. Safety-relevant systems have to be developed, analyzed, and certified according to safety standards such as IEC 61508. These standards demand the application of safety analyses such as Fault Tree Analysis and Failure Mode and Effect Analysis. Starting the safety analysis of each product variant of a SSPL from scratch is complex and very time-consuming. However, there are only few convincing cases, where SSPL approaches have been followed in safety engineering. To pave the way for a broader adoption of SSPL approaches, this paper reports practical experiences with industrial-strength methods and tools along an adaptive cruise control SSPL. The paper demonstrates how commercial tools can be used (i) to analyze safety-related aspects already in the architectural design, (ii) to model the results as component integrated component fault trees (C2FT), and (iii) to systematically reuse C2FT in the safety analysis of a concrete product. The results of the case study show that C2FT (i) can be easily integrated into a feature-oriented development process of SSPL, (ii) facilitate early consideration of safety in domain engineering, and (iii) reduce effort and complexity of safety analyses in application engineering.

In Software Engineering, reuse of artifacts is essential for high productivity. Different studies have shown that efficient reuse needs systematic planning and realization. Variability Management plays a key role in Software Product Line Engineering. We investigate code artifacts and variability models of a real-world Software Product Line over time in order to clarify whether code and variability model evolve congeneric. Furthermore, we suggest and test metrics that would allow detecting variability erosion in the code based on changes in the variability model.

Software Product Line (SPL) has arisen as an approach for developing a family of software-intensive systems at lower costs, within shorter time, and with higher quality. In particular, SPL is supported by a product line architecture (sometimes also referred to as reference architecture) that captures the architectures of a product family. From another perspective, a special type of architecture that contains knowledge about a specific domain has been increasingly investigated, resulting in the research area of Reference Architecture. In spite of the positive impact of this type of architecture on reuse and productivity, the use of the knowledge contained in existing reference architectures in order to develop SPL has not been widely explored yet. The main contribution of this paper is to present a process, named ProSA-RA2PLA, that systematizes the use of reference architectures for building product line architectures. To illustrate the application of this process, we have built a product line architecture for an SPL of software testing tools using a reference architecture of that domain. Based on initial results, we have observed that benefits can be achieved, mainly regarding improvement in reuse and productivity to develop SPL.

Successful software products evolve continuously to meet the changing stakeholder requirements. For software product lines, modifying variability is an additional challenge that must be carefully tackled during the evolution of the product line. This bears considerable challenges for industry as understanding on how variability realizations advance over time is not trivial. Moreover, it may lead to an erosion of variability, which needs an investigation of techniques on how to identify the variability erosion in practice, especially in the source code. To address various erosion symptoms, we have investigated the evolution of a large-scale industrial product line over a period of four years. Along improvement goals, we have researched a set of appropriate metrics and measurement approaches in a goal-oriented way, applied them in this case study with tool support, and interpreted the results including identified erosion symptoms.

FMSPLE 2012 is the third edition of the FMSPLE workshop series, traditionally affiliated with SPLC, which aims to connect researchers and practitioners interested in raising the efficiency and the effectiveness of SPLE through the application of innovative analysis approaches and formal methods.

The term bug prevalence is derived from the medical world vocabulary and applied to Software Product Line (SPL), meaning all products that are affected by one particular bug. In single systems development, this concept is not relevant since a bug is either present or not. However, when it comes to SPL, analyzing the bug prevalence of a certain bug is still a challenge and a highly relevant topic, since the same bug may be present in several products. To support this analysis, the main contribution of this paper is the Product Genealogy approach. A core concept in our approach is the Product Genealogy Tree, in which the hierarchy of products in the SPL is represented, reflecting how each product evolved or was derived from another or from the core assets. In this context, the benefit of such a tree is the rapid visualization of the product's structure in the SPL, providing input on which products are to be examined initially. Besides that, in this paper we introduce a novel analogy between the medical genetics world and SPL in order to better explain the principles of our approach.

Successful software products evolve continuously to meet the changing stakeholder requirements. For software product lines, an additional challenge is that variabilities, characteristics that vary among products, change as well over time. That challenge must be carefully tackled during the evolution of the product line infrastructure. This is a significant problem for many software development organizations, as practical guidelines on how to evolve core assets, and especially source code, are missing.

Successful Software Product Lines (SPLs) evolve over time. However, one practical problem is that during SPL evolution the core assets, especially the code, tend to become complicated and difficult to understand, use, and maintain. Typically, more and more problems arise over time with implicit or already lost adaptation knowledge about the interdependencies of the different system variants and the supported variability. In this paper, we present a model-based SPL improvement process that analyzes existing large-scale SPL reuse infrastructure to identify improvement potential with respective metrics. Since Conditional Compilation (CC) is one of the most widely used mechanisms to implement variability, we parse variability-related facts from preprocessor code. Then we automatically extract an implementation variability model, including product configuration and variation points that are structured in a hierarchical variability tree. The extraction process is presented with concrete measurement results from an industrial case study.

This workshop will bring together researchers interested in raising the efficiency and the effectiveness of Software Product Line Engineering by applying innovative analysis approaches and formal methods.

With the advent of new computing paradigms, such as Ubiquitous Computing, Ambient Intelligence, and Cyber Physical Systems, promising application domains like Ambient Assisted Living (AAL) and Car2Car have emerged. One key concern in these application domains is that systems are required to dynamically adapt in reaction to changes within the system or its environment. As a consequence, it is indispensable to incorporate corresponding facilities within systems, yielding adequate adaptation behavior to appropriately react on such dynamic changes. The definition of adaptation behavior is, however, a complex task in its own. In order to help engineers working on adaptive systems, we propose in this paper a generic testbed that allows specifying adaptation strategies and evaluating them in a runtime context to improve the adaptation behavior. Our approach further introduces basic visualization features as a means for the engineers to better evaluate the complex dynamic behavior resulting from runtime adaptation.

IT-based living assistance systems focusing on the support of people with special needs in their daily routine have to continuously monitor and assist them in an appropriate way. To this end, we have developed a monitoring and assistance component including a hybrid reasoner that is able to adapt planned and running treatments according to the current situation and context. In this paper, we explain the underlying approaches followed in the reasoner, describe the reasoning technologies used for this task and its sub-tasks, and present some first evaluation results.

In this paper, we present an integrated system concept for the living assistance domain based on ambient intelligence technology and discuss the resulting challenges for the software engineering discipline. Automated living assistance systems represent a promising approach for the prolongation of an independent and self-conducted life of handicapped and elderly people thereby, enhancing their quality of life and minimizing the need for manual social/medical care. It is demonstrated that living assistance systems must realize flexibility and adaptability at the algorithmic, architectural and human interface level to an extent unknown in present systems. The construction of robust, trustworthy living assistance systems is an extremely challenging task and requires novel approaches for dependable self-adapting software architectures, resource efficiency, and self-adapting multi-modal human-computer interfaces. The resulting consequences and challenges for the discipline of software engineering are outlined in this paper.