Skip to main content
VARIETE: Variability in Portfolios of Dependable Systems
VARIETE: Variability in Portfolios of Dependable Systems
Pages and Files
Add "All Pages"
Copenhagen Meeting on Variability 2014
Copenhagen Meeting on Variability Management
Monday, March 3rd
IT University of Copenhagen
Rued Langgards Vej 7
Room: Auditorium 1 (ground floor, access directly from atrium, if confused ask reception)
Register online HERE
(for onsite participation)
Program (see abstracts in the bottom of the page)
(time adjustments still possible, all times CET)
09.00 Coffee, light breakfast
09.30 Opening. Andrzej Wasowski
ECCO! - Extraction and Composition for Clone-and-Own -
Alexander Egyed (Johannes Kepler University, Linz)
Managing variability in a software chrestomathy
- Ralf Lammel (University of Koblenz-Landau, Germany)
The language consequences of exploring an industrial case using CVL
- Øystein Haugen (SINTEF, Norway)
Every journey has an end." Birth, life and death of product lines
- Danilo Beuche (pure-systems, Germany)
Structural feature interaction patterns: case studies and guidelines
- Sandro Schulze (TU Braunschweig, Germany)
14.30 Coffee break
15:00 (no video)(no slides)
N-Way Merge: Merging Multiple Products
- Julia Rubin (Haifa Research Lab, IBM Research)
Deriving Variants with Variability in Space and Time
- Christoph Seidl (TU Dresden, Germany)
Multi-Objective Test Suite Optimization for Incremental Product Family Testing
- Malte Lochau (TU Darmstadt, Germany)
17:15 closing discussion
Krzysztof Czarnecki, Ina Schaefer, Andrzej Wasowski and Michał Antkiewicz
How to get to ITU from the airport and from the town
For stays in the city we recommend Hotel Opera (
) , which is a bit more expensive, but also conveniently located on the metro line (Kongens Nytorv, 2-3 stations from ITU).
Cheap modern hotel well connected to ITU is Cabinn Metro:
. It is located out of town, but very easily reachable, only 3 metro stations away. Food available in the nearby Field's mall
Another cheap hotel close to ITU is Hotel København
(beware! shared bathroom facilities in some rooms. Walking distance from ITU).
ECCO! - Extraction and Composition for Clone-and-Own
To keep pace with the increasing demand for custom-tailored software systems, companies often apply a practice called clone-and-own. Thereby, a company builds an initial version of a system and then copies and adapts it with every new customer. Instead of a single, configurable system the company ends up with a portfolio of multiple, similar variants. Clone-and-own has widespread industrial use because it requires no major upfront investments compared to infrastructures facilitating reuse. Yet, it lacks a methodology for systematic reuse and for addressing the resulting feature interaction problems. This talk proposes ECCO! (Extraction and Composition for Clone-and-Own), a novel approach to actively support software engineers in applying clone-and-own. A software engineer selects the desired features and ECCO! finds the proper software artifacts for the copying step and then guides the software engineer during the manual completion by hinting which software artifacts may be missing or may need adaptation. We evaluated our approach on 4 case studies, covering 305 variants having up to 344KLOC, and found that precision and recall of composed products quickly reach a near optimum.
"Every journey has an end." Birth, life and death of product lines.
The talk focuses on often overlooked aspects of product line engineering. While a product line in full blossom can bring many benefits, its much harder to bring a product line into life, bring it through the hard times of infancy and also into a peaceful and happy retirement. We will look at the different stages of the product line's life and the implication for the organization developing the product line.
Managing variability in a software chrestomathy.
A software chrestomathy collects software systems exercising different languages, technologies, and designs. One such chrestomathy is 101 -- which is discussed in this presentation. The central use case of 101 is that programmers consult individual systems to learn about languages, technologies, and designs of interest. Accordingly, the individual systems better be self-contained from the point of view of the user. However, the collected systems are heavily redundant in terms of contained code units. In fact, some if not most systems were initiated by a cloning step, followed by diverse forms of extension, refinement, replacement, translation, and others. Clearly, such code sharing should be captured in some way to facilitate propagation of changes. Again, a conservative software product line approach is not attainable because it would disrupt the primary use case where users want to study the individual systems; it would also disrupt the developers of those systems, as they are normally interested only in one system or a few variations, therefore showing little interest in operating constantly at the level of product-line engineering. Thus, a virtual platform is needed here. Interestingly, the virtual platform for a chrestomathy would not only simplify the propagation of changes, but it would also directly support a secondary (nevertheless important) use case where programmers want to understand (explore) the relationship between different (similar) systems. In this talk, I discuss the vision towards obtaining a virtual platform for 101, the underlying assumptions regarding use cases, and related challenges.
The language consequences of exploring an industrial case using CVL.
SINTEF and ITU have been involved with Autronica in the VARIES project. Autronica makes advanced fire alarm systems for diverse settings sucha as airports and cruise ships. We report from the experiences that we have gained from exploring the use of CVL (Common Variability Language) in this context and what consequences our experiences could have creating an enhancement of CVL also considering the fact that CVL standardization has been stalled.
Structural feature interaction patterns: case studies and guidelines.
Feature interactions have been an intensive field of research for more than a decade. Recently, it gained much attention in the context of software product lines (SPLs), a methodology that takes features explicitly into account to distinguish between similar yet different programs. In its very essence, feature interactions occur whenever the presence of two or more features leads to a considerable (and maybe unwanted) change of the behavior of the underlying program. Amongst others, feature interactions may occur on source code level, for example, in form of additional code that is needed due to interacting features. In this paper, we focus on such structural interactions. Particularly, we investigate structural feature interaction patterns, that is, patterns that are related to structural feature interactions, and vice versa. To this end, we propose an approach to detect design patterns in feature-oriented SPLs. We show that such design patterns exist on feature level and these patterns involve feature interactions. Based on our results, we reason about feature interactions in the presence of design patterns. Particularly, we show when feature interactions occur and that they are beneficial, for example, to achieve a higher degree of abstraction. Furthermore, we propose an initial guideline when certain design patterns are applicable.
N-Way Merge: Merging Multiple Products
Merging is widely recognized as an essential step in a variety of software development activities. For example, the process of unifying a set of related products into a product line representation involves merging multiple inputs into one. Yet, most of the existing works focus on merging two inputs only.
In this talk, we look into the problem of merging artifacts from multiple inputs, a.k.a. the n-way merge problem. We explain why the n-way merge problem is NP-hard and explore its existing approximate solutions. We show that these solutions do not scale for software artifacts of realistic size and propose our own heuristic n-way merge algorithm that is superior to other practical approaches in terms of its accuracy. We then discuss further ideas for n-way merge heuristics, including one from the field of gaming.
Deriving Variants with Variability in Space and Time.
Hyper Feature Models (HFMs) capture variability in space and time and delta modeling is principally capable of realizing changes related to both types of variability by means of transformation, e.g., by employing delta languages generated with DeltaEcore. However, currently it is impossible to respect versions of HFMs in the variant derivation process of SPLs so that only products of the SPL for one particular state in time can be created. To remedy this problem, we illustrate how to couple HFMs with a delta-based variability mechanism to include evolution information of the problem space in the variant derivation process. For this purpose, we introduce a distinction of configuration and evolution deltas to represent variability in space and time, respectively. We establish a mapping between logical expressions of features and versions to the respective types of delta modules. We further define an implicit evaluation order for delta modules assigned to features and versions of an HFM to make the application procedure both deterministic and sound. With this contribution, it is possible to employ the variability information of HFMs to derive actual software products of an SPL containing aspects of both variability in space and time.
Multi-Objective Test Suite Optimization for Incremental Product Family Testing.
The design of an adequate test suite is usually guided by identifying test requirements which should be satisfied by the selected set of test cases. To reduce testing costs, test suite minimization heuristics aim at eliminating redundancy from existing test suites. However, recent test suite minimization approaches lack (1) to handle test suites commonly derived for families of similar software variants under test, and (2) to incorporate fine-grained information concerning cost/profit goals for test case selection. We propose a formal framework to optimize test suites designed for sets of software variants under test w.r.t. multiple conflicting cost/profit objectives. The problem representation is independent of the concrete testing methodology. We apply integer linear programming (ILP) to approximate optimal solutions. We further develop an efficient incremental heuristic for deriving a sequence of representative software variants to be tested for approaching optimal profits under reduced costs. We evaluated the algorithm by comparing its outcome to the optimal solution. In addition, we plan to apply the approach to an industrial, safety-critical case study from the automation engineering domain.
help on how to format text
Turn off "Getting Started"