Simon Urli

SPLEMMA: a generic framework for controlled-evolution of software product lines

Managing in a generic way the evolution process of feature-oriented Software Product Lines (spls) is complex due to the number of elements that are impacted and the heterogeneity of the spls regarding artifacts used to define them. Existing work presents specific approaches to manage the evolution of spls in terms of such artifacts, i.e., assets, feature models and relation definitions. Moreover stakeholders do not necessarily master all the knowledge of the spl making its evolution difficult and error-prone without a proper tool support. In order to deal with these issues, we introduce SPLEmma, a generic framework that follows a Model Driven Engineering approach to capture the evolution of a spl independently of the kind of assets, technologies or feature models used for the product derivation. Authorized changes are described by the spl maintainer and captured in a model used to generate tools that guide the evolution process and preserve the consistency of the whole spl. We report on the application of our approach on two spls: YourCast for digital signage systems, and SALOON, which enables generation of configurations for cloud providers.

Using composite feature models to support agile software product line evolution

Managing continuous change in a Software Product Line (SPL) is one of the challenges now faced by the SPL engineering community. On the one hand, the SPL paradigm captures the intrinsic variability of a software based on a systemic vision of the software to model. On the other hand, Agile Software Development advocates the incremental development of software based on constant interaction with a customer community. In this paper, we present an approach based on Composite Feature Models (CFM) to support the agile evolution of a SPL. This study is driven by the refactoring of a daily used application (information broadcasting system), in the context of a nationally funded project. Preliminary results show that CFMs support the incremental development of a SPL based on interactions with a community, tackling the challenge of SPL continuous evolution.

Handling complex configurations in software product lines: a tooled approach

As Software Product Lines (SPLs) are now more widely applied in new application fields such as IT or Web systems, complex and large-scale configurations have to be handled. In these fields, the strong domain orientation leads to the need to manage interrelated SPLs and multiple instances of configured sub-products, resulting in complex configurations that cannot be easily represented by simple sets of features. In this paper we propose a tooled approach to manage such SPLs through a domain model that interrelates several feature models in a consistent way. The approach thus shifts part of the domain knowledge to the problem space and supports the derivation of complex configurations with multiple instantiations and associations of sub-products. We also report on the application of our approach to an industrial-strength software development in the field of digital signage.

A visual support for decomposing complex feature models

In Software Product Line (SPL) engineering, Feature Models (FMs) are widely used to capture and manage variability in a sound and organized fashion. Though semantics, notations and reasoning support are well established, maintaining large FMs is still an open problem. As large FMs naturally contain different concerns, some related to domains, others being inherently cross-cutting ones, it is challenging to find a decomposition that will tame this complexity and ease maintenance. This paper presents a visual representation of dependent FMs useful in decomposing a large FM while quantitatively visualizing constraints between and inside them. This Variability Blueprint is intuitive enough to enable the SPL maintainer to confine dependencies between FMs in a small set of identified features inside each decomposed FM. We describe our blueprint and report on its application on two case studies.

Managing a Software Ecosystem Using a Multiple Software Product Line: A Case Study on Digital Signage Systems

With the advent of Web 2.0, the growth of developer teams and user communities increases the number of software ecosystems: software platforms developed and maintained in a decentralized way by external contributors. As complexity grows, these large software systems become more and more complex to manage and to adapt to specific user needs. In this paper, we report on a case study on the development of a digital signage software system called Your Cast. Based on several years experience evolving Your Cast from a single system to a medium-scale ecosystem, we show how organizing it as a multiple software product line helps in organizing the software platform, taming some management tasks for a growing community, and giving more capabilities to final users to build their own products.

How to exploit domain knowledge in Multiple Software Product Lines

As Software Product Lines (SPL) are inevitably moving towards a multiple form to tackle issues of reuse and complexity, variability management across the composed SPLs is still addressed with basic inter-constraints. Based on two disjoint case studies (digital signage and cloud computing), we identified this challenging problem for the SPL community. In this paper we describe how the domain knowledge needs to be exploited to support a more complete definition of Multiple Software Product Lines (MSPL). Such an exploitation implies the definition of a domain-driven definition of configuration and an order independent configuration process.

Experiences in teaching variability modeling and model-driven generative techniques

Teaching software engineering is an activity that needs to constantly evolve to cope with new paradigms, principles and techniques. In this paper, we briefly report on several years of experience in teaching both generative techniques in a model-driven engineering context and variability modeling related to software-product line engineering. Our current practice relies on making students progress on running projects that they evolve with different techniques along a semester. We also discuss the obtained benefits and some perspectives.

Model-driven composition of multiple software product lines

Software Product Lines (SPL) allows to build software at lower cost by reusing domain-specific software assets [5]. These artifacts are both common and variant parts of a software family. Variability is usually managed considering all software variants come from the same root. However, building software by assembling external components from different domains is now an encouraged and widespread practice. Then it becomes necessary to be able to manage composition of products from multiple SPLs from different domains [3]. Our work is focused on the way to create a SPL allowing this kind of composition.