Product Line Engineering Workshop'2013 @ University of Waterloo

On Dec 09, 2013, at the University of Waterloo, we hosted a one-day workshop about product line engineering.

The workshop was attended by nearly 150 participants from around the world, including 36 registered in-person participants and 57 registered on-line participants.

Read more about the agenda and the talk abstracts. View recordings. Download presentation slides.

Organized by Michał Antkiewicz, Krzysztof Czarnecki, Andrzej Wąsowski, Ina Schaefer.

Sponsored by

NECSIS logo       University of Waterloo Logo


8:30am-9:00am - light refreshments/coffee (30min)

10:10am-10:30am - BREAK (20min)

12:00pm-1:00pm - LUNCH (1h)

2:00pm-2:20pm - BREAK (20min)

3:20pm-3:30pm - transfer to DC1302 (10 min)

(optional) DINNER - not provided, we'll self organize in groups and go either to Uptown Waterloo or University Plaza.

Abstracts and Slides

  • Krzysztof Czarnecki, "Product Line Engineering Workshop Welcome" [slides]

  • Julia Rubin, "Cloned Product Variants: From Ad-Hoc to Well-Managed Software Reuse" [slides]

Software Product Line Engineering approaches promote strategic, well-managed software reuse. In practice, however, the adoption of such approaches is still limited. Instead, products are often established ad-hoc, e.g., by copying existing variants and modifying them to fit the requirements of a new customer or market segment (the “clone-and-own” approach).

In this talk, we investigate the reuse culture in organizations that employ cloning to realize their product lines. By analyzing cloning practices and development activities in several industrial product lines, we show that an efficient management of clones relies on both (1) the unification of the cloned variants into single-copy representations promoted by product line engineering methods and (2) the construction of a management infrastructure on top of existing variants, which allows to mitigate the disadvantages of cloning while leveraging its advantages. These two directions, in fact, coexist and complement each other even within a single organization during the transition from ad-hoc to managed reuse -- a process that usually takes several years.

Based on the analysis, we build the foundations for management of cloned product variants, scoping and structuring the required support and providing a roadmap for future research directions.

  • Michael Godfrey, "All We Like Sheep: Copy/Paste as a Principled Engineering Tool" [slides]

Source code cloning -- that is, copy / paste / edit of source code snippets -- is often accused of being a bad development practice: The code base may become bloated and unnecessarily complicated over time, bugs found in one clone may not be propagated to the others, and poor design and lazy engineering may become commonplace. In this talk that summarizes some older work, I will show how this view is unnecessarily harsh. I will instead suggest that cloning can be -- and often is -- used as a principled engineering technique. I will present a taxonomy of the use of cloning as observed in industrial systems, and present quantitative evidence that principled use of source code cloning can improve the design of a system.

  • Michał Antkiewicz, "Flexible Product Line Engineering with a Virtual Platform" [slides]

Cloning is widely used for creating new product variants. While it has low adoption costs, it often leads to maintenance problems. Long term reliance on cloning is discouraged in favor of systematic reuse offered by product line engineering (PLE) with a central platform integrating all reusable assets. Unfortunately, adopting an integrated platform requires a risky and costly migration.

We propose an approach to achieving the benefits traditionally associated with an integrated platform, while retaining the benefits of cloning and without requiring the high-risk migration. Instead of physically integrating the assets, they should be distributed across projects, but remain reusable thanks to the metadata about them. The distributed assets together with the meta-data form a virtual platform, which provides the same functionality as the integrated platform, but aims at greatly reducing the risk of adoption of PLE as compared to starting with ad-hoc cloning.

  • Christian Kaestner, "Variability Mining" [slides]

Software product line engineering is an efficient means to generate a set of tailored software products from a common implementation. However, adopting a product-line approach poses a major challenge and significant risks, since typically legacy code must be migrated toward a product line. Our aim is to lower the adoption barrier by providing tool support. In this talk, we explore different strategies from different legacy systems with and without variability. We extract existing variability from legacy systems, where it was implemented with conditional compilation or plain parameters, we locate features in legacy code that did not have variability, and we analyze deltas of cloned applications to migrate to a product line. If possible, we include domain knowledge in each extraction step.

  • Sandro Schulze, "Mining Model Variability" [slides]

Model-Driven Engineering (MDE) has become an important methodology for software development. With MDE, a common approach for reuse is clown-and-own that is, reusing an existing model by copying and modifying it to meet changed or new requirements. This, in turn, increases the effort for evolution and maintenance and may affect the model quality. In my talk, I present an approach we currently working on for reactively mining variability amongst related models for extracting their common and variable parts in order to overcome current problems of

  • Sarah Nadi, "Automatically Extracting Configuration Constraints" [slides]

Highly configurable systems offer configuration options for tailoring software to specific needs. Not all combinations of configuration options are valid, and constraints arise for technical or non-technical reasons. To reason about configurations, it is valuable to formally describe the constraints in a variability model. To support creating variability models, we propose an approach to automatically extract configuration constraints from C code, based on build-time errors and a novel feature-effect heuristic. We analyze the feasibility of our approach on four highly configurable open-source systems, and use the results to qualitatively and quantitatively study the various kinds of constraints in existing variability models. We find that while substantial parts of the variability model can be reverse-engineered from the codebase, significant expert and domain knowledge is still needed to construct complete variability models. We believe that our approach, tooling, and experimental results support researchers and practitioners working on variability model re-engineering, evolution, and consistency-checking techniques, and can especially aid in the process of Software Product Line migration.

  • Leonardo Passos, "Variability Evolution in the Large: a View Point from the Systems Software Domain"[slides]

Variability-aware software systems offer a large degree of customization, allowing users to configure the target system according to their own preferences or needs. Such variability is pervasive to the artifacts in the system, making the latter subject to the coevolution of its variability model and related artifacts (e.g., code, mappings, architectural models, etc.) Interestingly, research has mostly focused on variability evolution as it happens in variability models alone, while discarding consequent changes elsewhere. Such research is heavily based on randomly generated variability models, or in fictitious systems and evolution scenarios. As expected, the current understanding of variability evolution is far from complete. This shortage, is directly reflected in existing tools and solutions, as industry claim them ineffective in practice. In addition, the unbalanced focus on variability models has not given rise to uncovering key quality characteristics of a sustainable variability evolution, as that information is not identifiable by assessing the evolution of a variability model, but rather, the realization of its features, as it happens in code.

Attempting to mitigate this overall lack of knowledge, we set to study large and complex real-world variability-aware software systems and how they evolve over time. Specifically, we set to study four systems in the systems domain engineering, and how changes in their variability model relate to other artifacts. From that, we derive a holistic understanding by summing up all changes across different artifacts, and report which evolution scenarios occur in practice, what causes them to occur, how changes are made, and how our findings impact existing solutions and techniques. In addition, we study the evolution history of three large and complex operating systems, and set to collect key characteristics that allow their variability to evolve in a sustainable manner, without causing major ripple effects in existing parts when new features are introduced. As this is work in progress, we report our current results and set next steps.

  • Ian Davis, "A novel approach to automatic extraction of configuration parameters from industrial code" [slides]

Owl Computing Technologies provides software and hardware that facilitates secure unidirectional data transfer across the internet. Bash scripts are used to facilitate customer installation of Owl’s client/server software, and to provide high level management, control, and monitoring of client/server interfaces. With the evolution of more robust scripting languages, Owl now wishes to convert their bash scripts to other scripting languages. As part of this conversion exercise the configuration and customization of their bash scripts will no longer involve direct end user nodifications of the script logic. It will instead be achieved through appropriate modification of a supporting XML configuration file, which is read by each script. This avoids the risk that end users erroneously change scripts, and makes legitimate end user customization of their scripts simpler, more obvious, and easier to discern.

An open source fact extractor was implemented that determines the dynamic usage made of every variable within an arbitrary bash script. This tool reports errors in a script and generates an XML configuration file that describes variable usage. Those variables whose value may not be assigned by an end user are manually removed from this XML configuration file. A second program reads this configuration file, generates the appropriate bash variable assignment statements, and these are then applied within bash by using the bash 'eval' command. Collectively this provides a simple mechanism for altering arbitrary bash scripts so that they use an external XML configuration file, as a first step in the larger exercise of migrating bash scripts to other scripting languages.

  • Jo Atlee, "Feature Interactions: the Good, the Bad, and the Ugly" [slides]

Feature orientation is an increasingly popular method for decomposing a software-development task into subproblems -- in this case, features -- that can be tackled individually and incrementally. Feature orientation is particularly relevant in software product lines, where a family of similar products (e.g., smart phones, automotive software) is understood, constructed, managed, and evolved in terms of its common and optional features. One challenge to feature orientation is that product developers need to consider how combinations of feature interact with each other. The Feature Interaction Problem is that the number of interactions to consider is exponential in the number of features. As a result, developers find that their work in adding a new feature is dominated by the tasks to detect, analyze, and verify interactions with existing features. This presentation will give an overview of research on feature modularity and interactions, including (1) a language for modelling features as separate feature modules, whose composition is a model of a product line, (2) a tool for analyzing a model of a product line (rather than analyzing each of the separate products), and (3) a strategy for coordinating features to avoid certain classes of interactions.

2012.12.09-Rubin-Cloned-Product-Variants-From-Ad-Hoc-to-Well-Managed-Software-Reuse.ppsx1.31 MB
2013.12.09-Godfrey-All-we-like-sheep-Copy-paste-as-a-principled-engineering-tool.ppsx1.16 MB
2013.12.09-Antkiewicz-Flexible-Product-Line-Engineering-with-a-Virtual-Platform.ppsx536.36 KB
2013.12.09-Kaestner-Variability-Mining.ppsx6.39 MB
2012.12.09-Schulze-Mining-Model-Variability.ppsx8.71 MB
2012.12.09-Nadi-Automatically-Extracting-Configuration-Constraints.ppsx2.85 MB
2012.12.09-Passos-Variability-Evolution-in-the-large.ppsx2.47 MB
2012.12.09-Davis-A-novel-approach-to-automatic-extraction-of-configuration-parameters-from-industrial-code.ppsx1001.81 KB
2013.12.09-Czarnecki-Welcome.ppsx1.02 MB
2013.12.09-Atlee-Feature-Interactions.pdf3.95 MB