Feature modelling is a cornerstone of software product line engineering, providing a means to represent software variability through features and their relationships. Since its inception in 1990, feature modelling has evolved through various extensions, and after three decades of development, there is a growing consensus on the need for a standardised feature modelling language. Despite multiple endeavours to standardise variability modelling and the creation of various textual languages, researchers and practitioners continue to use their own approaches, impeding effective model sharing. In 2018, a collaborative initiative was launched by a group of researchers to develop a novel textual language for representing feature models. This paper introduces the outcome of this effort: the Universal Variability Language ( UVL ), which is designed to be human-readable and serves as a pivot language for diverse software engineering tools. The development of UVL drew upon community feedback and leveraged established literature in the field of variability modelling. The language is structured into three levels – Boolean, Arithmetic, and Type – and allows for language extensions to introduce additional constructs enhancing its expressiveness. UVL is integrated into various existing software tools, such as FeatureIDE and flamapy, and is maintained by a consortium of institutions. All tools that support the language are released in an open-source format, complemented by dedicated parser implementations for Python and Java. Beyond academia, UVL has found adoption within a range of institutions and companies. It is envisaged that UVL will become the language of choice in the future for a multitude of purposes, including knowledge sharing, educational instruction, and tool integration and interoperability. We envision UVL as a pivotal solution, addressing the limitations of prior attempts and fostering collaboration and innovation in the domain of software product line engineering.

Control software in the Cyber-Physical Production System domain continuously evolves to cater to customer needs. Addressing customer needs involves developing new functional requirements or modifying existing functionalities, leading to the creation of product variants. Clone-and-own is a common reuse strategy in which the closest variant in project history is cloned and then modified to derive a new variant. Platform-oriented reuse is an alternative strategy that builds a configurable platform to derive variants. Adopting both reuse strategies for existing systems requires common and variant-specific artifacts to be extracted and maintained. This paper proposes two extraction methodologies that extract common and variant-specific artifacts from existing systems for systematic reuse. We evaluate the two extraction methodologies by applying them to multiple industrial and academic control software case study systems developed using IEC 61499. We conduct quantitative analysis of the extracted artifacts, considering factors such as the total effort required to derive variants, the number and size of artifacts that need maintenance, and their evolution using the two extraction methodologies. Our proposal suggests different variants of control software that lead to the creation of artifacts that are not only more optimal but also easier to maintain using a specific extraction methodology.

Distributed stream processing frameworks help building scalable and reliable applications that perform transformations and aggregations on continuous data streams. This paper introduces ShuffleBench, a novel benchmark to evaluate the performance of modern stream processing frameworks. In contrast to other benchmarks, it focuses on use cases where stream processing frameworks are mainly employed for shuffling (i.e., re-distributing) data records to perform state-local aggregations, while the actual aggregation logic is considered as black-box software components. ShuffleBench is inspired by requirements for near real-time analytics of a large cloud observability platform and takes up benchmarking metrics and methods for latency, throughput, and scalability established in the performance engineering research community. Although inspired by a real-world observability use case, it is highly configurable to allow domain-independent evaluations. ShuffleBench comes as a ready-to-use open-source software utilizing existing Kubernetes tooling and providing implementations for four state-of-the-art frameworks. Therefore, we expect ShuffleBench to be a valuable contribution to both industrial practitioners building stream processing applications and researchers working on new stream processing approaches. We complement this paper with an experimental performance evaluation that employs ShuffleBench with various configurations on Flink, Hazelcast, Kafka Streams, and Spark in a cloud-native environment. Our results show that Flink achieves the highest throughput while Hazelcast processes data streams with the lowest latency.

Software product line engineering aims to systematically generate similar products or services within a given domain to reduce cost and time to market while increasing reuse. Various studies recognize the success of product line engineering in different domains. Software variability have increased over the years in many different domains such as mobile applications, cyber–physical systems or car control systems to just mention a few. However, software product line engineering is not as widely adopted as other software development technologies. In this paper, we present an empirical study conducted through a survey distributed to many software development companies. Our goal is to understand their need of software variability management and the level of knowledge the companies have regarding software product line engineering. The survey was answered by 127 participants from more than a hundred of different software development companies. Our study reveals that most of companies manage a catalog of similar products in a way or another, they mostly document the features of products using text or spreed sheet based documents and more than 66% of companies identify a base product from which they derive other similar products. We also found a correlation between the lack of Software Product Line (SPL) knowledge and the absence of reuse practices. Notably, this is the first study that explore software variability needs regardless of a company’s prior knowledge of SPL. The results encourages further research to understand the reason for the limited knowledge and application of software product line engineering practices, despite the growing demand of variability management.

Cyber-Physical Production Systems (CPPSs), such as automated car manufacturing plants, execute a configurable sequence of production steps to manufacture products from a product portfolio. In CPPS engineering, domain experts start with manually determining feasible production step sequences and resources based on implicit knowledge. This process is hard to reproduce and highly inefficient. In this paper, we present the Extended Iterative Process Sequence Exploration (eIPSE) approach to derive variability models for products, processes, and resources from a domain-specific description. To automate the integrated exploration and configuration process for a CPPS, we provide a toolchain which automatically reduces the configuration space and allows to generate CPPS artifacts, such as control code for resources. We evaluate the approach with four real-world use cases, including the generation of control code artifacts, and an observational user study to collect feedback from engineers with different backgrounds. The results confirm the usefulness of the eIPSE approach and accompanying prototype to straightforwardly configure a desired CPPS.

Industrial-scale control software is designed as variability-intensive, i.e., highly configurable and adaptable software, to support diverse hardware capabilities and to fulfill diverse customer requirements. Various control software architectures have been proposed for developing highly configurable and adaptable control software. However, each architecture has its strengths and weaknesses in configurability and adaptability. Measuring the suitability of a given architecture to deal with variability can further guide control software engineers in implementing highly configurable and adaptable control software. In this paper, we propose measurement approaches for IEC 61499-based control software that indicate how well a particular architecture can manage variability. Control software engineers are first encouraged to describe all the functionalities in their system. They can also describe which elements must be added or removed when implementing a particular functionality. They then store these descriptions using a variability mechanism called delta models. Next, we can measure the size of delta models, the cohesion and coupling of the control software modules, and the degree of mapping complexity between features and delta models. We argue that by using our proposed measurements, we can indicate whether the control software’s architecture is suitable for variability-intensive software.

The field of industrial automation has witnessed a significant increase in software development and maintenance efforts in recent years. This can be attributed to the demand for shorter product life cycles and customized products, leading to increasingly complex applications. As a result, control software engineers are facing new challenges. In this paper, we present our tool for visualizing industrial automation software. It provides engineers with a unique perspective on their large-scale applications. The tool offers several benefits, including convenient tracing of control and information flow across multiple levels of hierarchy, applying metrics to the visualization, and various interaction methods. The tool is tightly integrated into an existing IDE, providing a unique workflow for software analysis and maintenance. We discuss the experiences of engineers of our industry partner, who have been using the tool, and next steps.

Software size and complexity in all kinds of domains increase rapidly in recent times, making software maintenance and reusability increasingly difficult. Analysis of existing software and subsequent re-modularization can help with these challenges. Although software re-modularization can be time- and resource-intensive, it can support engineers in improving the quality of their systems in the future. Code can contain certain patterns, such as code smells, that define some kind of problematic implementation that is usually inefficient and hinders future development. We explore the use of a semantic clustering algorithm, which aims to minimize the code smell "Feature Envy". We apply this algorithm recursively to create a multi-level hierarchy. With this approach, we explore the re-modularization of existing IEC 61499 control systems. First tests we conducted on example implementations of a capping station and a real-life-sized industrial control system show a significant reduction of Feature Envy and thus the coupling between modules using this approach.

IEC 61499 is a standard for developing distributed industrial control software. It supports the configurability of the control software as the application model is platform-independent and separated from the system model that defines the hardware configuration specification. Thus, it can be used to develop control software for highly configurable Cyber-Physical Production Systems (CPPS). To address their customers’ requirements, companies that build CPPSs over time develop many variants of such production systems, typically through clone-and-own reuse, which increases engineering and maintenance efforts. Managing the control software variability in CPPSs in a systematic manner would facilitate software reuse and reduce the cost of developing and maintaining these systems. However, the IEC 61499 standard itself offers only limited capabilities for managing variability, e.g., by utilizing a library of modular components or by following certain design patterns. In this paper, we propose an approach to systematically manage IEC 61499-based control software using a (textual) delta modeling approach. Delta modeling is a prominent concept in the Software Product Line (SPL) domain for expressing and maintaining software variability. We show how our delta modeling approach can express control software variability and provide a semi-automatic control software generator. We evaluate the usability of our approach by applying it to multiple case studies as well as by performing a user study, in which control software engineers used our delta modeling approach. Our evaluation results indicate potential benefits of our delta modeling approach to implement and maintain control software through software generation.

Engineering Cyber-Physical Production Systems (CPPSs) heavily relies on Domain-Specific Languages (DSLs), which are tailored to a specific class of problems inherent to CPPSs. DSLs enable non-programming experts to solve problems in their domain, such as modeling production processes, implementing control software, or managing the variability of production systems. A DSL ecosystem encompasses the entire infrastructure (e.g., libraries and tools) built around its language and contributes to the successful and easy adoption thereof by domain experts. We present a maturity evaluation model for DSL ecosystems serving two aims: to developers, it reveals missing but essential aspects of the ecosystem, and users (e.g., industrial companies) can evaluate the maturity of a DSL ecosystem. We propose criteria to evaluate the maturity of DSL ecosystems and apply them to existing, publicly available DSLs which have been adopted in CPPSs. The results demonstrate that all components of the model are covered and they allow for deriving hypotheses about DSL ecosystems used in CPPSs.

Analyzing and maintaining the quality of control software is pivotal in the plant manufacturing industry. During software development, certain negative patterns frequently occur. These negative patterns are called code smells and are characterized by code that is hard to understand, maintain or expand. One such smell is duplicated code, also known as clones. Clones often result from clone-and-own reuse, which is common in practice. Detecting clones is crucial to avoid bug propagation and keep maintenance efforts low. This work deals with detecting clones in control software written in the domain-specific modeling language IEC 61499.

Cyber-Physical Production Systems (CPPSs) consist of deeply intertwined physical and software components. In the last decade, the number of mechatronic components (sensors, actuators, etc.) in a system is increasing enormously to enable more flexible, intelligent production with more support for customization. Mechatronic variability, like different variants of sensors or actuators in the system, directly affects the control software. The standardization of physical interfaces of mechatronic components has provided well-defined plug-and-play interaction. Conversely, software components in the CPPS domain still face the issue of standardizing functionality. Software adaptability often leads engineers to develop control software for new mechatronic variants by just copying and modifying existing software. This leads to multiple and completely separate instances of the control software and a high development and maintenance effort. The core functionality of the control software should be standardized and reused as much as possible to reduce the development effort and improve overall reliability. This paper discusses an approach to standardize core functionality of IEC 61499-based control software. Our design approach encapsulates the process core functionality and defines standard interfaces for interacting with mechatronic variant software components. We evaluate our design approach by comparing it to the traditional clone-and-own approach for an academic case study system, a capping station. Additionally, we assess the impact of adding a new variant in the control software and analyze what changes are needed to keep the same core functionality. When introducing new mechatronic variants in combination with standardized core functionality, our design approach reduces the overall control software variance and maintenance effort.

The rising complexity of modern production systems raises the need for evaluating the code quality also in control software engineering. Complexity metrics can help identifying code that is difficult to maintain and may benefit from a refactoring. Although complexity metrics have already been adapted to the domain-specific languages (DSLs) used for cyber-physical production systems (CPPSs), literature on whether developers benefit from using these metrics is limited. Also, the complexity perception of code by the domain experts remains to be investigated. The perceived difficulty of comprehending a program can vary among developers and also between different implementation variants of the same functionality. We therefore asked industrial experts, who have experience in the respective DSLs, to rate the complexity of semantically equivalent implementations to find out which metric best represents their complexity perception and whether there are differences between implementation variants. The examples used in the study were inspired, in parts, by an open source library for IEC 61131-3. We found that the Cognitive Complexity metric is a useful representation of the software complexity in the domain, as it best matched the domain experts’ perception of complexity. These metrics should therefore be supported by the analysis tools.

Several software systems are built upon stream processing architectures to process large amounts of data in near real-time. Today’s distributed stream processing systems (DSPSs) spread the processing among multiple machines to provide scalable performance. However, high-performance and Quality of Service (QoS) in distributed stream processing are challenging to predict, achieve, and maintain. While many studies focus on evaluating or improving the performance of stream processing, getting a comprehensive view of the current state of DSPSs and their performance in real-world deployments is challenging. In this paper, we present a systematic mapping study of the literature on DSPSs’ performance. We discuss existing challenges, the most used DSPSs, achieved performance, and future trends. Our results demonstrate that performance is still one of the major concerns in stream processing, with several solutions available and different outcomes regarding the metrics, execution environments, and use cases considered. Moreover, there is a need for better benchmarks and workloads as well as for performance improvements by increasing efficiency and utilizing modern hardware. Our study intends to help software engineering practitioners and researchers to understand how to choose the most suitable DSPS to build efficient data-intensive architectures.

Cyber-Physical Production Systems (CPPSs) are complex, highly-configurable systems interacting with their environment by sensors and actuators. Software in CPPS typically exists in a plethora of variants, developed to fulfill customer and technology requirements, which have to be maintained over a long time. Support for variability management can foster systematic reuse and configurability, but this requires a significant investment of resources to explicitly document or model variability. Additionally, we need to define the reusable engineering artifacts and their variability corresponding to the documents or models. Furthermore, the documents or models need to be maintained and kept consistent with the artifacts evolving frequently. In this short paper, we propose to (semi-)automatically capture delta models describing differences be-tween CPPS control software variants and support generating these variants based on a product line platform. Specifically, we envision a change recording mechanism and model comparison approaches for control software developed using IEC 61499, a domain-specific modeling language used for developing distributed control in CPPSs. We argue that both approaches can significantly reduce the development and maintenance effort for delta models.

Cyber-Physical Production Systems (CPPSs) are envisioned as next-generation adaptive production systems combining modern production techniques with the latest information technology. A CPPS creates a complex environment between different domains (mechanical, electrical, software engineering), requiring multidisciplinary solutions to tackle growing complexity issues and reduce (maintenance) effort. Software plays an increasingly important role in assuring an effective and efficient operation of CPPSs. However, software engineering methods applied for CPPSs seem to lag behind modern software engineering methods, where tremendous progress has been made in the last years. We initiated the Software Engineering in Cyber-Physical Production Systems Workshop (SECPPS-WS) to analyze and overcome this gap. After two instances with mostly academic participants, we conducted a full-day workshop with nine industry representatives from eight companies that develop and maintain CPPSs. Each industry representative presented their current work and challenges. We collected these challenges and condensed a categorized list of challenges backed by industry statements and literature. This paper presents the resulting list and pointers to (partial) solutions to offer guidance for academia and identify promising research opportunities in this area.

Cyber-Physical Production Systems (CPPSs) are highly variable systems of systems comprised of software and hardware interacting with each other and the environment. The increasing integration of technologies and devices has brought an unprecedented level of automation and customization. At the same time, it has also increased the efforts to maintain highly complex and heterogeneous systems. Although engineering practices support the reuse of common components to ease the development and maintenance of the systems in different projects, the identification of common components is still manually performed, which is a time-consuming, error-prone task. In this paper, a novel approach identifying repeating patterns in CPPSs based on artificial intelligence techniques is presented. This approach allows finding exact and similar components to support the CPPS design. Furthermore, it enables the maintenance of common components by reusing predefined types thereby reducing development effort. We implemented and evaluated our approach in an industry case study on developing CPPS control software with IEC 61499.

Bad Smells are sub-optimal software structures or patterns. They can obstruct the understandability of a software system and cause maintenance issues. As a result, it is critical to avoid Bad Smells. While the subject is well-researched in software engineering, it remains an unresolved issue in industrial automation, e.g., when developing control software in the context of a Cyber-Physical Production System (CPPS). In this short paper, we present possible detection methods for Feature Envy, a smell that indicates bad modularization of a software system. We explain how these methods can be applied to analyze control software developed in IEC 61499. We present first results as well as next steps.

In recent years, the field of industrial automation is experiencing a dramatic increase of software development and maintenance effort. Driven by shorter product life-cycles and customizable products, production systems are becoming more and more complex, presenting new challenges for control software engineers. In this paper, we report on a visualization concept we applied to industrial automation software. It allows automation software developers to take a look at their software system from a new perspective. Various ways of interacting with the visualization offer further benefits, such as the convenient tracing of control and information flow across multiple hierarchies. We conducted a workshop with five industrial domain experts as a first evaluation of the usefulness of the visualization. Based on their feedback, we discuss open questions and next steps.

Modern production plants are complex Cyber-Physical Production Systems with an ever-increasing share of software controlling and automating their operation. The customization of these systems to the needs of their customers and their frequent evolution over a typically long life-cycle result in a plethora of variants to be managed. However, reuse still is mainly done in an opportunistic way, relying on copy-paste-modify strategies. More systematic, strategic reuse would help to reduce costs and time to market, but requires approaches that can be applied to domain-specific languages for developing distributed control software. In this paper, we propose an approach to manage variability in IEC 61499-based systems using delta-oriented variability modeling. We discuss open challenges and outline a research agenda for variability management in IEC 61499.

In software product line engineering, engineers and researchers use variability models to explicitly represent the commonalities and variability of software systems to foster systematic reuse. Variability modeling has been a field of extensive research for over three decades, including Systematic Literature Reviews (SLRs) and Systematic Mapping Studies (SMSs) to categorize and compare different approaches. Much effort goes into such (secondary) studies, partly because they are often done from scratch and searching for relevant studies for specific research questions is tedious. Systematic reuse of search results would benefit the community by improving the efficiency and quality of such studies. In this paper, we report on creating a curated data set of 78 key SLR/SMS publications and primary studies (e.g., surveys) on variability modeling by conducting a tertiary SMS on variability modeling. When using such a curated paper data set for a secondary study, we estimate researchers can save up to 50 percent effort in the search phase. We present the publicly available data set, which includes categorization of the studies and provides update mechanisms. We see our data set as a foundation for building a Variability Modeling Body of Knowledge (VMBoK). We illustrate the efficient use of the data set in two SLR examples. We argue that our process and the data set can be useful for various research communities to improve the efficiency and quality of secondary (and tertiary) studies.

automated Production Systems (aPS) represent a special type of mechatronic system characterized by a high complexity in hardware and software, lifetimes of up to several decades, and strong coupling of the involved disciplines, i.e., mechanics, electrics/electronics, and control software. Questionnaire studies have proven to be a valuable means of identifying obstacles in industrial software development that hinder the implementation of emerging technologies in the context of Industry 4.0 and, thus, the realization of Cyber-Physical Production Systems. However, the heterogeneity of different industrial sectors in terms of, e.g., the type of production processes or legal specifications, makes it difficult to compare the maturity of control software development across companies, even within the same industry. A software maturity benchmark for companies operating in similar industries is, however, a prerequisite for assessing a company’s strengths and weaknesses and thereby applying tailored solutions to improve the software and, thus, the competitiveness. This paper describes the results of a questionnaire study in two international companies operating in the same industrial sector. Specifically, location-, company-, and industry-specific maturity characteristics are analyzed and discussed, and it is concluded that the selected questionnaire is capable of identifying deviations and similarities in software maturity, even in an international environment, given that the companies are prefiltered based on the covered supply chain step. Hence, assuming a sufficiently large number of participants per industry, it enables a questionnaire-based industry comparison in future work, which was not possible until now.

Industrial control applications are usually designed by domain experts instead of software engineers. These experts frequently use visual programming languages based on standards such as IEC 61131-3 and IEC 61499. The standards apply model-based engineering concepts to abstract from hardware and low-level communication. Developing industrial control software is challenging due the fact that such systems are usually one-of-a-kind systems that have to be maintained for many years. These challenges, together with the growing complexity of control software, require very usable model-based development environments for visual programming languages. However, so far only little empirical research exists on the practical usefulness of such environments, i.e., their usability and utility. In this paper, we discuss common control software maintenance tasks and tool capabilities based on existing research and show the realization of these capabilities in 4diac IDE. We first performed a walkthrough of the demonstrated capabilities using the cognitive dimensions of notations framework from the field of human-computer interaction. We then improved the tool and conducted a user study involving ten industrial automation engineers, who used 4diac IDE in a realistic control software maintenance scenario. Our findings demonstrate how the usefulness of IDEs can be successfully investigated using a multi-phase approach that includes a walkthrough and a user study. We discuss lessons learned and derive general implications with respect to large-scale applications for developers of IDEs that we deem applicable in the context of (visual) model-based engineering tools.

Abstract Many 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 plethora of variability modeling approaches has been developed in the last 30 years. Feature modeling and decision modeling became the most common and well-known groups of variability modeling approaches. Even within these groups, however, there are many different variants of approaches. Also, there are many other approaches such as Orthogonal Variability Modeling, UML-based variability modeling, and many more. Despite past and ongoing efforts, there is no standard variability modeling approach the community can agree on. Many approaches have been developed for a certain purpose and have been demonstrated to be useful for at least that purpose, e.g., domain analysis or automated derivation and configuration of products from a software product line. Still, industry frequently develops their own custom variability management solutions. In this short paper, we discuss our first ideas towards developing a framework for variability model transformations. It would allow researchers and practitioners to experiment with and compare different approaches and tools and switch from one approach or tool to another. We demonstrate the basic feasibility of our idea by transforming a feature model into a decision model. We conclude with a research agenda regarding variability model transformations.

Complex software systems evolve frequently, e.g., when introducing new features or fixing bugs during maintenance. However, understanding the impact of such changes on system behavior is often difficult. Many approaches have thus been proposed that analyze systems before and after changes, e.g., by comparing source code, model-based representations, or system execution logs. In this paper, we propose an approach for comparing run-time constraints, synthesized by a constraint mining algorithm, based on execution logs recorded before and after changes. Specifically, automatically mined constraints define the expected timing and order of recurring events and the values of data elements attached to events. Our approach presents the differences of the mined constraints to users, thereby providing a higher-level view on software evolution and supporting the analysis of the impact of changes on system behavior. We present a motivating example and a preliminary evaluation based on a cyber-physical system controlling unmanned aerial vehicles. The results of our preliminary evaluation show that our approach can help to analyze changed behavior and thus contributes to understanding software evolution.

Most software development organizations nowadays use issue-tracking tools to manage software processes throughout the life-cycle. Still, understanding development processes, keeping track of process execution, and reacting to deviations in projects remains challenging. In particular, the actual process usually differs from the process perceived by developers, making it hard to define the processes developers are expected to carry out. This is further challenged by frequently changing processes and process variations in different projects and teams. In this paper we describe an empirical study in which we applied a constraint mining approach from the field of software monitoring to automatically extract process definitions in the form of constraints. Specifically, we applied the approach to datasets extracted from four real-world projects (using the Jira issue-tracking tool) in a company developing a recreational activities platform. The mined constraints describe the boundaries of the actual processes and thus help to understand process behavior. Constraints can be frequently re-mined to understand process evolution. The mined constraints can also be used to monitor future processes to detect problems in the development process early on. We involved a domain expert to evaluate the usefulness of our results and investigated to what extent the mined constraints reflect the official development process of the company. We also report mining results for different issue types, across projects, and over different time windows.

Many requirements monitoring approaches have been proposed that check key properties of systems and their interactions at runtime. Some of these approaches also visualize monitoring results and provide details on requirements violations to end users. However, only few studies exist about the usefulness of requirements monitoring tools for practitioners, particularly regarding visualization. In this paper, we present a user study we have conducted with both industrial practitioners and researchers to assess the usefulness of visualization capabilities we have been developing for an event-based requirements monitoring tool. These capabilities allow users to monitor the status of the involved systems, to view trends and statistics, and to inspect the events and data that led to specific violations when diagnosing their root cause. We first performed a walkthrough of the tool using the cognitive dimensions of notations framework from the field of human-computer interaction. We then conducted a user study involving five software engineers of a large company from the automation software domain and four researchers. Using the tool's visualization capabilities all subjects succeeded in monitoring a real-world automation system and in diagnosing violations. Subjects regarded the visualization capabilities as essential for understanding the behavior of a complex system. Based on the study results we derive implications, opportunities, and risks of using visualization in requirements monitoring tools.

Online activities such as social networking, online shopping, and consuming multi-media create digital traces, which are often analyzed and used to improve user experience and increase revenue, e. g., through better-fitting recommendations and more targeted marketing. Analyses of digital traces typically aim to find user traits such as age, gender, and nationality to derive common preferences. We investigate to which extent the music listening habits of users of the social music platform Last.fm can be used to predict their age, gender, and nationality. We propose a feature modeling approach building on Term Frequency-Inverse Document Frequency (TF-IDF) for artist listening information and artist tags combined with additionally extracted features. We show that we can substantially outperform a baseline majority voting approach and can compete with existing approaches. Further, regarding prediction accuracy vs. available listening data we show that even one single listening event per user is enough to outperform the baseline in all prediction tasks. We also compare the performance of our algorithm for different user groups and discuss possible prediction errors and how to mitigate them. We conclude that personal information can be derived from music listening information, which indeed can help better tailoring recommendations, as we illustrate with the use case of a music recommender system that can directly utilize the user attributes predicted by our algorithm to increase the quality of it’s recommendations.

Unmanned aerial vehicles (UAVs) are becoming increasingly pervasive in everyday life, supporting diverse use cases such as aerial photography, delivery of goods, or disaster reconnaissance and management. UAVs are cyber-physical systems (CPS): they integrate computation (embedded software and control systems) with physical components (the UAVs flying in the physical world). UAVs in particular and CPS in general require monitoring capabilities to detect and possibly mitigate erroneous and safety-critical behavior at runtime. Existing monitoring approaches mostly do not adequately address UAV CPS characteristics such as the high number of dynamically instantiated components, the tight int elements, and the massive amounts of data that need to be processed. In this paper we report results of a case study on monitoring in UAVs. We discuss CPS-specific monitoring challenges and present a prototype we implemented by extending \reminds, a framework for software monitoring so far mainly used in the domain of metallurgical plants. Additionally, we demonstrate the applicability and scalability of our approach by monitoring a real control and management system for UAVs in simulations with up to 30 drones flying in an urban area.

Industrial software systems are often systems of systems (SoS) whose full behavior only emerges during operation. They therefore require monitoring techniques to observe systems and detect deviations from their requirements. The focus of existing monitoring approaches, however, is mainly on detecting violations of expected behavior, while support for diagnosing violations is typically limited or even neglected. Diagnosis is particularly challenging in SoS due to their technological heterogeneity and the diversity of development tools in use. Uncovering the root cause of a violation typically requires developers to trace violations to artifacts such as source code or requirements documents, which is difficult without detailed domain knowledge. In this paper we describe our experiences of developing a tool-supported approach facilitating the diagnosis of requirements violations in SoS. We describe how we complemented a requirements monitoring model with a system artifact model relating SoS artifacts needed for diagnosis with monitored events. We customized our approach to an industrial SoS and conducted a scenario-based walkthrough with engineers developing the SoS and engineers and researchers unfamiliar with it. The results of our evaluation have shown that our approach can significantly ease diagnosing violations in a real-world SoS.

This extended abstract summarizes our article entitled "Teaching Software Product Lines: A Snapshot of Current Practices and Challenges" published in the ACM Transactions on Computing Education, vol. 18 in 2017 (http://doi.acm.org/10.1145/3088440). The article reports on three initiatives we have conducted with scholars, educators, industry practitioners, and students to understand the connection between software product lines and education and to derive recommendations for educators to continue improving the state of practice of teaching SPLs.

Education has a key role to play for disseminating the constantly growing body of Software Product Line (SPL) knowledge. In a sense, every researcher in SPL should think about how to teach SPL. This workshop aims to explore and explain the current status and ongoing work on teaching SPLs at universities, colleges, and in industry (e.g., by consultants). This third edition will continue the effort made at SPLTea'14 and SPLTea'15. In particular we seek to attract experience reports of teaching SPLs. We expect several lightning talks that report on traditional questions like: what is the targeted audience? What is the place in the curriculum? What is the material (slides, tools, books, etc) used? What are the benefits of teaching SPLs? What are the difficulties and barriers? We also welcome opinionated and provocative talks that encourage discussions about the topic. Another goal of the workshop is to populate an open repository of resources dedicated to SPL teaching: http://teaching.variability.io

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.

This extended abstract summarizes our paper entitled "A Comparison Framework for Runtime Monitoring Approaches" published in the Journal on Systems and Software in vol. 125 in 2017 (https://doi.org/10.1016/jjss.2016.12.034). This paper provides the following contributions: (i) a framework that supports analyzing and comparing runtime monitoring approaches using different dimensions and elements; (ii) an application of the framework to analyze and compare 32 existing monitoring approaches; and (iii) a discussion of perspectives and potential future applications of our framework, e.g., to support the selection of an approach for a particular monitoring problem or application context.

Domain-specific languages (DSLs) are frequently used in software engineering. In contrast to general-purpose languages, DSLs are designed for a special purpose in a particular domain. Due to volatile user requirements and new technologies DSLs, similar to the software systems they describe or produce, are subject to continuous evolution. This work explores existing research on DSL evolution to summarize, structure and analyze this area of research, and to identify trends and open issues. We conducted a systematic mapping study and identified 98 papers as potentially relevant for our study. By applying inclusion and exclusion criteria we selected a set of 34 papers relevant for DSL evolution. We classified and analyzed these papers to create a map of the research field. We conclude that DSL evolution is a topic of increasing relevancy. However, research on language evolution so far did not focus much on the characteristics DSLs exhibit. Also, there are not many cross-references between our primary studies meaning researchers are often not aware of potentially useful work. Our study results help researchers and practitioners working on DSL-based approaches to get an overview of existing research on DSL evolution and open challenges.

The full behavior of software-intensive systems of systems (SoS) emerges during operation only. Runtime monitoring approaches have thus been proposed to detect deviations from the expected behavior. They commonly rely on temporal logic or domain-specific languages to formally define requirements, which are then checked by analyzing the stream of monitored events and event data. Some approaches also allow developers to generate constraints from declarative specifications of the expected behavior. However, independent of the approach, deep domain knowledge is required to specify the desired behavior. This knowledge is often not accessible in SoS environments with multiple development teams independently working on different, heterogeneous systems. In this New Ideas Paper we thus describe an approach that automatically mines constraints for runtime monitoring from event logs recorded in SoS. Our approach builds on ideas from specification mining, process mining, and machine learning to mine different types of constraints on event occurrence, event timing, and event data. The approach further presents the mined constraints to users in an existing constraint language and it ranks the constraints using different criteria. We demonstrate the feasibility of our approach by applying it to event logs from a real-world industrial SoS.

Industrial software systems are often systems of systems (SoS) whose full behavior only emerges at runtime. The systems and their interactions thus need to be continuously monitored and checked during operation to determine compliance with requirements. Many requirements monitoring approaches have been proposed. However, only few of these come with tools that present and visualize monitoring results and details on requirements violations to end users such as industrial engineers. In this tool demo paper we present visualization capabilities we have been developing motivated by industrial scenarios. Our tool complements ReMinds, an existing requirements monitoring framework, which supports collecting, aggregating, and analyzing events and event data in architecturally heterogeneous SoS. Our visualizations support a `drill-down' scenario for monitoring and diagnosis: starting from a graphical status overview of the monitored systems and their relations, engineers can view trends and statistics about performed analyses and diagnose the root cause of problems by inspecting the events and event data that led to a specific violation. Initial industry feedback we received confirms the usefulness of our tool support. Demo video: https://youtu.be/iv7kWzeNkdk..

Software Product Line (SPL) engineering has emerged to provide the means to efficiently model, produce, and maintain multiple similar software variants, exploiting their common properties, and managing their variabilities (differences). With over two decades of existence, the community of SPL researchers and practitioners is thriving, as can be attested by the extensive research output and the numerous successful industrial projects. Education has a key role to support the next generation of practitioners to build highly complex, variability-intensive systems. Yet, it is unclear how the concepts of variability and SPLs are taught, what are the possible missing gaps and difficulties faced, what are the benefits, and what is the material available. Also, it remains unclear whether scholars teach what is actually needed by industry. In this article, we report on three initiatives we have conducted with scholars, educators, industry practitioners, and students to further understand the connection between SPLs and education, that is, an online survey on teaching SPLs we performed with 35 scholars, another survey on learning SPLs we conducted with 25 students, as well as two workshops held at the International Software Product Line Conference in 2014 and 2015 with both researchers and industry practitioners participating. We build upon the two surveys and the workshops to derive recommendations for educators to continue improving the state of practice of teaching SPLs, aimed at both individual educators as well as the wider community.

Complex software-intensive systems are often described as systems of systems (SoS) comprising heterogeneous architectural elements. As SoS behavior fully emerges during operation only, runtime monitoring is needed to detect deviations from requirements. Today, diverse approaches exist to define and check runtime behavior and performance characteristics. However, existing approaches often focus on specific types of systems and address certain kinds of checks, thus impeding their use in industrial SoS. Furthermore, as many SoS need to run continuously for long periods, the dynamic definition and deployment of constraints needs to be supported. In this paper we describe experiences of developing and applying a DSL-based approach for monitoring an SoS in the domain of industrial automation software. We evaluate both the expressiveness of our DSL as well as the scalability of the constraint checker. We also describe lessons learned.

The behavior of systems of systems (SoS) emerges only fully during operation and is hard to predict. SoS thus need to be monitored at runtime to detect deviations from important requirements. However, existing approaches for checking runtime behavior and performance characteristics are limited with respect to the kinds of checks and the types of technologies supported, which impedes their use in industrial SoS. In this tool demonstration paper we describe the ReMinds tool suite for runtime monitoring of SoS developed in response to industrial monitoring scenarios. ReMinds provides comprehensive tool support for instrumenting systems, extracting events and data at runtime, defining constraints to check expected behavior and properties, and visualizing constraint violations to facilitate diagnosis.

Many software systems today can be characterized as systems of systems (SoS) comprising interrelated and heterogeneous systems developed by diverse teams over many years. Due to their scale, complexity, and heterogeneity engineers face significant challenges when determining the compliance of SoS with their requirements. Requirements monitoring approaches are a viable solution for checking system properties at runtime. However, existing approaches do not adequately consider the characteristics of SoS: different types of requirements exist at different levels and across different systems; requirements are maintained by different stakeholders; and systems are implemented using diverse technologies. This paper describes a three-dimensional requirements monitoring model (RMM) for SoS providing the following contributions: (i) our approach allows modeling the monitoring scopes of requirements with respect to the SoS architecture; (ii) it employs event models to abstract from different technologies and systems to be monitored; and (iii) it supports instantiating the RMM at runtime depending on the actual SoS configuration. To evaluate the feasibility of our approach we created a RMM for a real-world SoS from the automation software domain. We evaluated the model by instantiating it using an existing monitoring framework and a simulator running parts of this SoS. The results indicate that the model is sufficiently expressive to support monitoring SoS requirements of a directed SoS. It further facilitates diagnosis by discovering violations of requirements across different levels and systems in realistic monitoring scenarios.

Education has a key role to play for disseminating the constantly growing body of Software Product Line (SPL) knowledge. Teaching SPLs is challenging; it is unclear, for example, how SPLs can be taught and what is the material available. This workshop aims to explore and explain the current status and ongoing work on teaching SPLs at universities, colleges, and in industry (e.g., by consultants). This second edition will continue the effort made at SPLTea'14. In particular we seek to design and populate an open repository of resources dedicated to SPL teaching.

In many domains systems need to run continuously and cannot be shut down for reconfiguration or maintenance tasks. Cyber-physical or cloud-based systems, for instance, thus often provide means to support their adaptation at runtime. The required flexibility and adaptability of systems suggests the application of Software Product Line (spl) principles to manage their variability and to support their reconfiguration. Specifically, Dynamic Software Product Lines (dspl) have been proposed to support the management and binding of variability at runtime. While spl evolution has been widely studied, it has so far not been investigated in detail in a dspl context. Variability models that are used in a dspl have to co-evolve and be kept consistent with the systems they represent to support reconfiguration even after changes to the systems at runtime. In this short paper we present a classification of the required operations for jointly evolving problem and solution space in a dspl. We analyze the impact of such operations on the consistency of a dspl and propose an approach to deal with the described issues. We describe a runtime monitoring system used in the domain of industrial automation software as an example of a dspl evolving at runtime to motivate and explain our work.

Education has a key role to play for disseminating the constantly growing body of Software Product Line (SPL) knowledge. Teaching SPLs is challenging and it is unclear how SPLs can be taught, what are the possible benefits, or what is the material available. This workshop aims to explore and explain the current status and ongoing work on teaching SPLs at universities, colleges, and in industry (e.g., by consultants). Participants will discuss gaps and difficulties faced when teaching SPLs, benefits to research and industry, different ways to teach SPL knowledge, common threads, interests, and problems. The overall goal is to strengthen the important aspect of teaching in the SPL community.

Many software systems today have system-of systems (SoS) architectures comprising interrelated and heterogeneous systems, which are developed by multiple teams and companies. Such systems emerge gradually and it is hard to analyze or predict their behavior due to their scale and complexity. In particular, certain behavior only emerges at runtime due to complex interactions between the involved systems and their environment. Monitoring the behavior of SoS at runtime is thus essential during development and evolution. However, existing monitoring approaches are often limited to particular architectural styles or technologies and are thus hard to apply in SoS architectures. In this paper we first analyze the challenges for monitoring SoS based on an industrial SoS for the automation of metallurgical plants. We then propose a flexible framework for monitoring heterogeneous systems within a SoS. We demonstrate its feasibility by applying it to two systems of an industrial SoS. We also report results of an evaluation assessing the framework's performance and scalability.

Context. Software engineering researchers conduct systematic literature reviews (SLRs) to build bodies of knowledge (BoKs). Unfortunately, relevant knowledge collected in the SLR process is not publicly available, which considerably slows down building BoKs incrementally. Objective. We present and evaluate the Systematic Knowledge Engineering (SKE) process to support efficiently building BoKs from published research. Method. SKE is based on the SLR process and on Knowledge Engineering practices to build a Knowledge Base (KB) by reusing intermediate data extraction results from SLRs. We evaluated the feasibility of applying SKE by building a Software Inspection BoK KB from published experiments and a Software Product Line BoK KB from published experience reports. We compared the effort, benefits, and risks of building BoK KBs regarding the SKE and the traditional SLR processes. Results. The application of SKE for incrementally collecting and organizing knowledge in the context of a BoK was feasible for different domains and different types of evidence. While the efforts for conducting the SKE and traditional SLR processes are comparable, SKE provides significant benefits for building BoKs. Conclusions. SKE enables researchers in a scientific community to reuse and incrementally build knowledge in a BoK. SKE is ready to be evaluated in other software engineering domains.

One of the greatest barriers on the way to the efficient creation, handling, and evolution of product lines is the complexity and scale of the underlying artifacts. In this context, the MAPLE/SCALE workshop focuses on the investigation of scalability issues and the application of model-driven concepts and techniques in software product line engineering (SPLE). The workshop explores how to handle product lines of realistic complexity and how to facilitate systematic and efficient product derivation.

In an industrial context, software systems are rarely developed by a single organization. For software product lines, this means that various organizations collaborate to provide and integrate the assets used in a product line. It is not uncommon that these assets themselves are built as product lines, a practice which is referred to as multi product lines. This cross-organizational distribution of reusable assets leads to numerous challenges, such as inconsistent configuration, costly and time-consuming integration, diverging evolution speed and direction, and inadequate testing.

Software systems are nowadays often configured by sales people, domain experts, or even customers instead of engineers. Configuration tools communicate the systems' variability to these end users and provide guidance for selecting and customizing the available features. However, even if a configuration tool creates technically correct systems, addressing the specific needs of business-oriented users remains challenging. We analyze existing configuration tools to identify key capabilities for guiding end users and discuss these capabilities using the cognitive dimensions of notations framework. We present an implementation of the capabilities in our configuration tool DOPLER CW. We performed a qualitative investigation on the usefulness of the tool's capabilities for user guidance in product configuration by involving nine business-oriented experts of two industry partners from the domain of industrial automation. We present key results and derive general implications for tool developers.

The MAPLE workshop focuses on the application of concepts and techniques from Model-driven Software Engineering (MDSE) in Software Product Line Engineering (SPLE). A particular focus is on techniques that allow to derive products from a product line more efficiently in order to maximize the return on investment and realize the expected benefits of SPLE techniques. The workshop covers both automated and interactive model-based techniques. As submissions, we particularly encourage research papers based on industrial experience and empirical studies as well as contributions, which identify and structure open challenges and research questions.

Industrial product lines are typically maintained for a long time and evolve continuously to address changing requirements and new technologies. Already derived products often have to be re-derived after such changes to benefit from new and updated features. Product line engineers thus frequently need to analyze the impact of changes to variability models to prevent unexpected changes of re-derived products. In this paper we present a tool-supported approach that informs engineers about the impacts of variability model changes on existing products. Regression tests are used to determine whether existing product configurations and generated product outputs can be re-derived without unexpected effects. We evaluate the feasibility of the approach based on changes observed in a real-world software product line. More specifically, we show how our approach helps engineers performing specific evolution tasks to analyze the change impacts on existing products. We also evaluate the performance and scalability of our approach. Our results show that variability change impact analyses can be automated using model regression testing and can help reducing the gap between domain engineering and application engineering.

Business calculations like break-even, return on investment, or cost are essential in many domains to support decision making while configuring products. For instance, customers and sales people need to estimate and compare the business value of different product variants. Some product line approaches provide initial support, e.g., by defining quality attributes in relation to features. However, an approach that allows domain engineers to easily define business calculations together with variability models is still lacking. In product configuration, calculation results need to be instantly presented to end users after making configuration choices. Further, due to the often high number of calculations, the presentation of calculation results to end users can be challenging. These challenges cannot be addressed by integrating off-the-shelf applications performing the calculations with product line tools. We thus present an approach based on dedicated calculation models that are related to variability models. Our approach seamlessly integrates business calculations with product configuration and provides support for formatting calculations and calculation results. We use the DOPLER tool suite to deploy calculations together with variability models to end users in product configuration. We evaluate the expressiveness and practical relevance of the approach by investigating the development of business calculations for 15 product lines from the domain of industrial automation.

The goal of the SPLC Doctoral Symposium is to provide a supportive environment that enables doctoral students to get feedback on and improve their research work. Students will have the opportunity to discuss their research, especially goals, methods, and preliminary results with experienced members of the community. Thus, the symposium offers a unique opportunity for Ph.D. students to gather valuable expert feedback with respect to their research work and to get into contact with other students who are at a similar stage. The overall aim of the symposium is to improve the quality of doctoral theses in the area of software product lines. The intent is to promote fruitful discussions and provide valuable feedback to the candidates.

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.

Many of the benefits expected from software product lines (SPL) [1-2] are based on the assumption that the additional investment required for domain engineering, pays off during application engineering when products are derived from the product line [3]. However, to fully exploit this we need to optimize application engineering processes and handle the reusable artifacts of an SPL in a systematic and efficient manner. In this context, the joint MAPLE/SCALE workshop focuses on two closely related aspects: how model-driven approaches can help to achieve systematic and efficient derivation of products and how scalability challenges can be addressed that arise from the application of SPL techniques to SPLs of realistic size and complexity. The workshop aims to explore and explicate the current status and ongoing work in model-driven approaches and/or scalability of SPLs and the transfer of knowledge between different disciplines and application domains.

In industrial settings, products are rarely developed by one organization alone. Software vendors and suppliers typically maintain their own product lines, which can contribute to a larger (multi) product line. The teams involved often use different approaches and tools to manage the variability of their systems. It is unrealistic to assume that all participating units can use a standardized and prescribed variability modeling technique. The configuration of products based on several models in different notations and with different semantics is not well supported by existing approaches. In this paper we present an integrative approach that provides a unified perspective to users configuring products in multi product line environments, regardless of the different modeling methods and tools used internally. We also present a technical infrastructure and a prototypic implementation based on Web Services. We show the feasibility of the approach and its implementation by using it with two different variability modeling approaches (one feature-based and one decision-oriented approach) on an example derived from industrial experience.

Industrial experiences show that support for sharing and deploying product line models and tools is essential when institutionalizing product line engineering. This paper presents key workflows together with an infrastructure providing support for this purpose. Our approach supports distributed users sharing work products during variability modeling, product derivation, and product line evolution. The approach is based on product line bundles (PLiBs) for packaging models and tool support for specific product lines. Using three industrial scenarios and an industrial product line example we demonstrate how our infrastructure supports the deployment of models and tools in practical settings.

The complexity of product line variability models makes it hard to maintain their consistency over time regardless of the modeling approach used. Engineers thus need support for detecting and resolving inconsistencies. We describe experiences of applying a tool-supported approach for incremental consistency checking on variability models. Our approach significantly improves the overall performance and scalability compared to batch-oriented techniques and allows providing immediate feedback to modelers. It is extensible as new consistency constraints can easily be added. Furthermore, the approach is flexible as it is not limited to variability models and it also checks the consistency of the models with the underlying code base of the product line. We report the results of a thorough evaluation based on real-world product line models and discuss lessons learned.

Developers of software engineering tools are facing high expectations regarding capabilities and usability. Users expect tools tailored to their specific needs and integrated in their working environment. This increases tools' complexity and complicates their customization and deployment despite available mechanisms for adaptability and extensibility. A main challenge lies in understanding and managing the dependencies between different technical mechanisms for realizing tool variability. We report on industrial experiences of applying a model-based and tool-supported product line approach for the customization and deployment of two Eclipse-based tools. We illustrate challenges of customizing these tools to different development contexts: In the first case study we developed variability models of a product line tool suite used by an industry partner and utilized these models for tool customization and deployment. In the second case study we applied the same approach to a maintenance and setup tool of our industry partner. Our experiences suggest to design software tools as product lines; to formally describe the tools' variability in models; and to provide end-user capabilities for customizing and deploying the tools.

Tool developers are facing high expectations regarding the capabilities and usability of software engineering tools. Users expect tools which are tailored to their specific needs and integrated in their environment. This increases the complexity of tools and makes their customization more difficult, although numerous mechanisms supporting adaptability and extensibility are available. In this experience paper we report on the lessons we have learned when developing a tool suite for product line engineering. Our experiences suggest that software engineering tools should be designed as product lines.

Software maintenance and evolution are among the most challenging and cost-intensive activities in software engineering. This is not different for software product lines due to their complexity and long life-span. New customer requirements, technology changes and internal enhancements lead to the continuous evolution of a product line's reusable assets. Due to the size of product lines, single stakeholders or teams can only maintain a small part of a system which poses additional challenges for evolution. This paper presents an approach supporting product line evolution by organizing variability models of large-scale product lines as a set of interrelated model fragments defining the variability of particular parts of the system. The approach allows semi-automatic merging of fragments into complete variability models. We also provide tool support to automatically detect changes that would make models and the architecture inconsistent. Furthermore, our approach supports the co-evolution of variability models and their respective meta-models. We illustrate the approach with examples from an ongoing industry collaboration.

To leverage the explicit and extensive use of shared software artifacts, many companies use a product line approach to build different variants of their products for use within a variety of systems. Product lines can be large and could easily incorporate thousands of elements together with relationships between those elements. This makes product line management and systematic product derivation extremely difficult.

Evolution is a permanent challenge in product line engineering. Reusable assets such as software components or documents evolve continuously due to new customer requirements or technology changes. This leads to modifications or extensions of the product line's variability models describing the reference architecture. Due to the large size of product lines, single stakeholders or teams can only maintain a small part of a system which poses additional challenges for evolution. This paper presents a tool-supported approach for building and maintaining variability models of large-scale product lines. We structure variability models into multiple model fragments of manageable size that can be created and maintained by individual teams. Model fragments can be merged semi- automatically into a variability model. We illustrate the approach with examples from ongoing industry collaboration.

Product line engineering comprises many heterogeneous activities such as capturing the variability of reusable assets, supporting the derivation of products from the product line, evolving the product line, or tailoring the approach to the specifics of a domain. The inherent complexity of product lines implicates that tool support is inevitable to facilitate smooth performance and to avoid costly errors. Product line engineering tools have to support heterogeneous stakeholders involved in diverse activities. Tool integration therefore is of particular importance to foster their seamless cooperation. However, the integration is difficult to achieve due to the diversity of models and work products. This paper describes the DOPLER tool suite which has been developed to provide such integrated support. The tool suite is flexible and extensible to support domain-specific needs

Deriving a product from a product line requires the involvement and cooperation of heterogeneous stakeholders such as customers, sales people, or engineers. Taking their different roles and needs into account is essential to exploit the possible benefits of product lines. In this paper we present the tool-supported product line engineering approach DOPLER. We demonstrate how the approach supports both non- technicians and engineers in product derivation and requirements engineering through a set of integrated tools.

Product derivation is the process of constructing products from the core assets in a product line. Guidance and support are needed to increase efficiency and to deal with the complexity of product derivation. Research has, however, devoted comparatively little attention to this process. In this paper we describe an approach for supporting product derivation. We show that variability models need to be prepared for concrete projects before they can be effectively utilized in the derivation process. Project-specific information and sales knowledge should be added and irrelevant variability should be pruned. We also present tool support and illustrate the approach using examples from ongoing research collaboration.

Understanding and modeling architectural variability is fundamental in product line engineering. Various extensions have been proposed to architecture description languages (ADLs) to deal with variability. Although these extensions are useful, we argue in this paper that decisions need to be treated as first-class citizens for modeling architectural variability. Decisions that have to be taken by different stakeholders during product derivation are an essential source to understand the variability at different levels (e.g., features, architecture, and implementation). We outline a decision-oriented approach to variability modeling and illustrate it with an example from our ongoing research collaboration with Siemens VAI.