An overview of Dynamic Software Product Line architectures and techniques: Observations from research and industry
---
paper_title: Dynamic Software Product Lines

paper_content:

The Software Engineering Institute (SEI) defines an SPL as a set of software-intensive systems that share a common, managed set of features satisfying the specific needs of a particular market segment or mission. A fundamental principle of SPLs is variability management, which involves separating the product line into three parts - common components, parts common to some but not all products, and individual products with their own specific requirements - and managing these throughout development. Using SPLs seeks to maximize reusable variation and eliminate wasteful generic development of components used only once. Although traditional SPL engineering recognizes that variation points are bound at different stages of development, and possibly also at runtime, it typically binds variation points before delivery of the software. In contrast, DSPL engineers typically aren't concerned with pre-runtime variation points. However, they recognize that in practice mixed approaches might be viable, where some variation points related to the environment's static properties are bound before runtime and others related to the dynamic properties are bound at runtime.
---
paper_title: A View of the Dynamic Software Product Line Landscape

paper_content:

Dynamic software product lines extend the concept of conventional SPLs by enabling software-variant generation at runtime. Recent studies yield insights into the current state of the DSPL field, research trends, and major gaps to address.
---
paper_title: Building Dynamic Software Product Lines

paper_content:

Dynamic software product lines extend existing product line engineering approaches by moving their capabilities to runtime, helping to ensure that system adaptations lead to desirable properties.
---
paper_title: Software Product Line Engineering Foundations Principles And Techniques

paper_content:

Thank you for reading software product line engineering foundations principles and techniques. Maybe you have knowledge that, people have look numerous times for their favorite books like this software product line engineering foundations principles and techniques, but end up in malicious downloads. Rather than reading a good book with a cup of coffee in the afternoon, instead they are facing with some infectious bugs inside their desktop computer.
---
paper_title: Dynamic software adaptation for service-oriented product lines

paper_content:

This paper describes a dynamic software adaptation approach and environment for service-oriented product lines. The approach uses a dynamic feature model and product line architecture for a family of service-oriented architectures (SOA), in which a member of the SOA can be dynamically adapted to a different member of the family at run-time. The approach integrates software product line and feature modeling concepts with SOA and dynamic software adaptation concepts. The approach is validated using a case study of a dynamic service-oriented product line.
---
paper_title: An Autonomous Engine for Services Configuration and Deployment

paper_content:

The runtime management of the infrastructure providing service-based systems is a complex task, up to the point where manual operation struggles to be cost effective. As the functionality is provided by a set of dynamically composed distributed services, in order to achieve a management objective multiple operations have to be applied over the distributed elements of the managed infrastructure. Moreover, the manager must cope with the highly heterogeneous characteristics and management interfaces of the runtime resources. With this in mind, this paper proposes to support the configuration and deployment of services with an automated closed control loop. The automation is enabled by the definition of a generic information model, which captures all the information relevant to the management of the services with the same abstractions, describing the runtime elements, service dependencies, and business objectives. On top of that, a technique based on satisfiability is described which automatically diagnoses the state of the managed environment and obtains the required changes for correcting it (e.g., installation, service binding, update, or configuration). The results from a set of case studies extracted from the banking domain are provided to validate the feasibility of this proposal.
---
paper_title: Strategies for variability transformation at run-time

paper_content:

More and more approaches propose to use Software Product Lines (SPLs) modelling techniques to implement dynamic adaptive systems. The resulting Dynamic Software Product Lines (DSPLs) present new challenges since the variability transformations used to derive alternative configurations have to be intensively used at runtime. This paper proposes to use the Common Variability Language (CVL) for modelling runtime variability and evaluates a set of alternative strategies for implementing the associated variability transformations. All the proposed strategies have been implemented and evaluated on the case-study of a smart-home system. Results show that the proposed strategies provide the same reconfiguration service with significant differences in quality-of-service.
---
paper_title: An Extensible Framework for Improving a Distributed Software System's Deployment Architecture

paper_content:

A distributed system's allocation of software components to hardware nodes (i.e., deployment architecture) can have a significant impact on its quality of service (QoS). For a given system, there may be many deployment architectures that provide the same functionality, but with different levels of QoS. The parameters that influence the quality of a system's deployment architecture are often not known before the system's initial deployment and may change at runtime. This means that redeployment of the software system may be necessary to improve the system's QoS properties. This paper presents and evaluates a framework aimed at finding the most appropriate deployment architecture for a distributed software system with respect to multiple, possibly conflicting QoS dimensions. The framework supports formal modeling of the problem and provides a set of tailorable algorithms for improving a system's deployment. We have realized the framework on top of a visual deployment architecture modeling and analysis environment. The framework has been evaluated for precision and execution-time complexity on a large number of simulated distributed system scenarios, as well as in the context of two third-party families of distributed applications.
---
paper_title: How dynamic is your Dynamic Software Product Line?

paper_content:

Recently, there have been increasing demands for the postponement of decisions on software adaptations and product variations to provide the flexibility required by dynamic environments and users. The goal is that software adaptations and product variations can be chosen even at runtime. As such, a research theme that addresses development issues for reusable and dynamically reconfigurable core assets has emerged and it is called dynamic software product lines (DSPLs) with its consequential need to manage runtime variability. Research on the use of runtime variability, however, is still heavily based on the specification of decisions during design time. That is, a system simply postpones “when to adapt” to runtime but “how to adapt” is already decided at design time. In this paper, we present a brief assessment of the current research in the area and discuss some research issues related to the feasibility of DSPL oriented approaches to build self-adaptive systems.
---
paper_title: Dynamic Software Product Lines

paper_content:

The Software Engineering Institute (SEI) defines an SPL as a set of software-intensive systems that share a common, managed set of features satisfying the specific needs of a particular market segment or mission. A fundamental principle of SPLs is variability management, which involves separating the product line into three parts - common components, parts common to some but not all products, and individual products with their own specific requirements - and managing these throughout development. Using SPLs seeks to maximize reusable variation and eliminate wasteful generic development of components used only once. Although traditional SPL engineering recognizes that variation points are bound at different stages of development, and possibly also at runtime, it typically binds variation points before delivery of the software. In contrast, DSPL engineers typically aren't concerned with pre-runtime variation points. However, they recognize that in practice mixed approaches might be viable, where some variation points related to the environment's static properties are bound before runtime and others related to the dynamic properties are bound at runtime.
---
paper_title: A feature-oriented approach to developing dynamically reconfigurable products in product line engineering

paper_content:

Dynamic product reconfiguration refers to making changes to a deployed product configuration while a system is running. Recently, there have been increasing demands for dynamic product reconfiguration in various application areas (e.g., ubiquitous computing, self-healing systems, etc.); however, most product line engineering methods in the literature have focused on the development of reusable core assets for statically configured products. In this paper, we propose a feature-oriented approach to develop dynamically reconfigurable core assets. This approach takes feature binding analysis results as a key design driver for identifying and managing variation points of dynamically reconfigurable products. We also provide a conceptual model for a reconfigurator, which monitors and manages product reconfiguration at run time. The method is illustrated with a home service robot product line example.
---
paper_title: Dynamic Software Product Lines for Service-Based Systems

paper_content:

Ageing populations and the necessity to reduceenvironmental impact raise new challenges on our living buildings.Convergence of home control systems (air conditioning,light management) and computer science, or house automation,allows to enhance comfort, security and health of inhabitants,and reduce energy consumption. Each of these abilities can beperceived as a service provided by the house automation system.Starting from this point, we developed ENTIMID , a middlewareable to make systems from different brands cooperate in a singleservice-based platform. Yet the proliferation and variability ofsuch services, and needs to tailor each system to a particularbuilding, make the design of these systems complex. In thisprospective paper, we explain how the notion of dynamic softwareproduct line facilitates such designs by providing sophisticatedtechniques for managing variability across services from designtime to runtime and allowing their automatic composition.
---
paper_title: Autonomic computing driven by feature models and architecture in FamiWare

paper_content:

A wireless sensor network is an example of a system that should be able to adapt its sensor nodes to some context changes with minimum human intervention. This means that the architecture of the middleware for sensors must encapsulate a dynamic mechanism to allow reconfiguration. We present a novel approach to achieve self-adaptation based on software product lines and on the autonomic computing paradigm for the FamiWare middleware. FamiWare uses feature models to represent the potential middleware configurations at runtime. Each configuration is automatically mapped to the corresponding architectural representation of a specific middleware product. Following the autonomic computing principles, FamiWare defines a reconfiguration mechanism that switches from one architectural configuration to another by means of executing a plan. This is possible thanks to the loosely coupled architecture of FamiWare based on an event-based publish and subscribe mechanism. We evaluate our work by showing that the resource consumption and the overhead are not so critical compared with the benefits of providing this self-adaptation mechanism.
---
paper_title: Dynamic software reconfiguration in software product families

paper_content:

This paper describes an approach for the dynamic reconfiguration of software product families. A software reconfiguration pattern is a solution to a problem in a software product family where the configuration needs to be updated while the system is operational. It defines how a set of components participating in a software pattern cooperate to change the configuration of a system from one configuration of the product family to another. An approach for the design of reconfiguration patterns and a change management model for software product families are also described. The paper concludes with a description of case studies and a proof-of-concept prototype.
---
paper_title: Designing and prototyping dynamic software product lines: techniques and guidelines

paper_content:

Dynamic Software Product Lines (DSPL) encompass systems that are capable of modifying their own configuration with respect to changes in their operating environment by using run-time reconfigurations. A failure in these reconfigurations can directly impact the user experience since the reconfigurations are performed when the system is already under the users control. Prototyping DSPLs at an early development stage can help to pinpoint potential issues and optimize design. In this work, we identify and addresses two challenges associated with the involvement of human subjects in DSPL prototyping: enabling DSPL users to (1) trigger the run-time reconfigurations and to (2) understand the effects of the reconfigurations. These techniques have been applied with the participation of human subjects by means of a Smart Hotel case study which was deployed with real devices. The application of these techniques reveals DSPL-design issues with recovering from a failed reconfiguration or a reconfiguration triggered by mistake. To address these issues, we discuss some guidelines learned in the Smart Hotel case study.
---
paper_title: Context Awareness for Dynamic Service-oriented Product Lines

paper_content:

This paper presents a Context-Aware Dynamic Software Product Line (DSPL) for building service oriented applications and adapting them at runtime in accordance with their using context. This DSPL, named CAPucine for Context-Aware Service-Oriented Product Line is based on two different processes for product derivation. The first process uses assets that represent features of the product family. The assets, represented as models, get composed and transformed in order to generate the product. The second process relates to dynamic adaptation. This process introduces context-aware assets that operate at runtime. These context-aware assets contain three kinds of data: the context when the assets can be modified, the place where the assets must be applied and the change that must be performed. The realization of these context-aware assets combines two runtime platforms. On the one hand,COSMOS is a context-aware framework connected to the environment by the use of sensors. On the other hand FraSCAti is a Service Component Architecture (SCA) platform with dynamic properties that enables to bind and unbind components at runtime. CAPucine allows designing and processing context-aware applications based on an SCA platform which is dynamic, introspectable, and reconfigurable in accordance with the context environment.
---
paper_title: Dynamic software adaptation for service-oriented product lines

paper_content:

This paper describes a dynamic software adaptation approach and environment for service-oriented product lines. The approach uses a dynamic feature model and product line architecture for a family of service-oriented architectures (SOA), in which a member of the SOA can be dynamically adapted to a different member of the family at run-time. The approach integrates software product line and feature modeling concepts with SOA and dynamic software adaptation concepts. The approach is validated using a case study of a dynamic service-oriented product line.
---
paper_title: Strategies for variability transformation at run-time

paper_content:

More and more approaches propose to use Software Product Lines (SPLs) modelling techniques to implement dynamic adaptive systems. The resulting Dynamic Software Product Lines (DSPLs) present new challenges since the variability transformations used to derive alternative configurations have to be intensively used at runtime. This paper proposes to use the Common Variability Language (CVL) for modelling runtime variability and evaluates a set of alternative strategies for implementing the associated variability transformations. All the proposed strategies have been implemented and evaluated on the case-study of a smart-home system. Results show that the proposed strategies provide the same reconfiguration service with significant differences in quality-of-service.
---
paper_title: Adding Standardized Variability to Domain Specific Languages

paper_content:

We show how a common language of variability can be used to enhance the expressiveness of a domain specific language (DSL). DSLs have been proposed as a mechanism for expressing variability. Variability between models in a given domain or of a family of systems is captured by language constructs, implying that all possible models in this language are the allowed variations. We explore the possibility of expressing variability in a language independently of the base modeling language. We explore how this works for small DSLs as well as for general purpose languages like UML. Implications of this approach are that the variability language can be standardized, and that DSLs do not have to include variability mechanisms.
---
paper_title: Automated analysis of feature models 20 years later: A literature review

paper_content:

Software product line engineering is about producing a set of related products that share more commonalities than variabilities. Feature models are widely used for variability and commonality management in software product lines. Feature models are information models where a set of products are represented as a set of features in a single model. The automated analysis of feature models deals with the computer-aided extraction of information from feature models. The literature on this topic has contributed with a set of operations, techniques, tools and empirical results which have not been surveyed until now. This paper provides a comprehensive literature review on the automated analysis of feature models 20 years after of their invention. This paper contributes by bringing together previously disparate streams of work to help shed light on this thriving area. We also present a conceptual framework to understand the different proposals as well as categorise future contributions. We finally discuss the different studies and propose some challenges to be faced in the future.
---
paper_title: A feature-oriented approach to developing dynamically reconfigurable products in product line engineering

paper_content:

Dynamic product reconfiguration refers to making changes to a deployed product configuration while a system is running. Recently, there have been increasing demands for dynamic product reconfiguration in various application areas (e.g., ubiquitous computing, self-healing systems, etc.); however, most product line engineering methods in the literature have focused on the development of reusable core assets for statically configured products. In this paper, we propose a feature-oriented approach to develop dynamically reconfigurable core assets. This approach takes feature binding analysis results as a key design driver for identifying and managing variation points of dynamically reconfigurable products. We also provide a conceptual model for a reconfigurator, which monitors and manages product reconfiguration at run time. The method is illustrated with a home service robot product line example.
---
paper_title: Adding variants on-the-fly: Modeling meta-variability in dynamic software product lines

paper_content:

Dynamic software product lines (DSPL) are software product lines (SPL) that support runtime variability. Runtime variability is typically interpreted as binding variation points at runtime. We emphasize meta-variability as an important dimension of runtime variability in DSPL. Whereas dynamic binding considers the runtime (de)activation of variants within the scope of a given variability model, meta-variability considers runtime changes to the variability model itself. Meta-variability is essential to support longlived software products that are subject to evolution. In this paper, we consider meta-variability in an industrial DSPL that is developed in a joint project with Egemin N.V., a leading company that provides full life cycle support for automated transportation systems (ATS). The contribution of this paper is threefold. First, we introduce a way to model meta-variability in DSPL in an explicit manner. Second, we put forward a meta-variability meta model that extends the variability meta model with concepts that explicitly support meta-variability. Third, we capture and apply metavariability in an industrial DSPL for automated transportation systems.
---
paper_title: Using Constraint Programming to Manage Configurations in Self-Adaptive Systems

paper_content:

Combining goal-modeling techniques with constraint programming provides the means to identify the variants best suited to the environmental contexts that a self-adaptive software system might encounter at runtime.
---
paper_title: An Autonomous Engine for Services Configuration and Deployment

paper_content:

The runtime management of the infrastructure providing service-based systems is a complex task, up to the point where manual operation struggles to be cost effective. As the functionality is provided by a set of dynamically composed distributed services, in order to achieve a management objective multiple operations have to be applied over the distributed elements of the managed infrastructure. Moreover, the manager must cope with the highly heterogeneous characteristics and management interfaces of the runtime resources. With this in mind, this paper proposes to support the configuration and deployment of services with an automated closed control loop. The automation is enabled by the definition of a generic information model, which captures all the information relevant to the management of the services with the same abstractions, describing the runtime elements, service dependencies, and business objectives. On top of that, a technique based on satisfiability is described which automatically diagnoses the state of the managed environment and obtains the required changes for correcting it (e.g., installation, service binding, update, or configuration). The results from a set of case studies extracted from the banking domain are provided to validate the feasibility of this proposal.
---
paper_title: Using Feature Diagrams with Context Variability to Model Multiple Product Lines for Software Supply Chains

paper_content:

Feature modeling is a key concept in product line engineering. Due to the large number of different features and relations in practice, feature models often become too complex to deal with. One of these complexities is caused by the need to support multiple product lines. In this paper we introduce the concept of a context variability model, which contain the primary drivers for variation, e.g. different geographic regions. The context variability model constrains the feature model, which makes it possible to model multiple product lines supporting several dimensions in the context space. We will discuss how this concept can support software supply chains. Here it can be used to facilitate the process of merging feature models during staged configuration. Our initial experimental results indicate that the approach is intuitive and straightforward to use, and can be applied with commercially available variability management tools.
---
paper_title: Autonomic computing driven by feature models and architecture in FamiWare

paper_content:

A wireless sensor network is an example of a system that should be able to adapt its sensor nodes to some context changes with minimum human intervention. This means that the architecture of the middleware for sensors must encapsulate a dynamic mechanism to allow reconfiguration. We present a novel approach to achieve self-adaptation based on software product lines and on the autonomic computing paradigm for the FamiWare middleware. FamiWare uses feature models to represent the potential middleware configurations at runtime. Each configuration is automatically mapped to the corresponding architectural representation of a specific middleware product. Following the autonomic computing principles, FamiWare defines a reconfiguration mechanism that switches from one architectural configuration to another by means of executing a plan. This is possible thanks to the loosely coupled architecture of FamiWare based on an event-based publish and subscribe mechanism. We evaluate our work by showing that the resource consumption and the overhead are not so critical compared with the benefits of providing this self-adaptation mechanism.
---
paper_title: Feature dependency analysis for product line component design

paper_content:

Analyzing commonalities and variabilities among products of a product line is an essential activity for product line asset development. A feature-oriented approach to commonality and variability analysis (called feature modeling) has been used extensively for product line engineering. Feature modeling mainly focuses on identifying commonalities and variabilities among products of a product line and organizing them in terms of structural relationships (e.g., aggregation and generalization) and configuration dependencies (e.g., required and excluded). Although the structural relationships and configuration dependencies are essential inputs to product line asset development, they are not sufficient to develop reusable and adaptable product line assets. Other types of dependencies among features also have significant influences on the design of product line assets. In this paper, we extend the feature modeling to analyze feature dependencies that are useful in the design of reusable and adaptable product line components, and present design guidelines based on the extended model. An elevator control software example is used to illustrate the concept of the proposed method.
---
paper_title: Feature-Oriented Analysis and Specification of Dynamic Product Reconfiguration

paper_content:

In many application domains, scenarios have been developed that benefit from the idea of ambience; Systems will not necessarily be activated by people anymore, but will react on their own to situations they recognize. It, thereby, must dynamically adapt itself to changes in the technical environment or user context. In addition, such dynamically reconfigurable products must be customized to the individual needs of particular users. Product line engineering can be applied to create these variants efficiently; however, means for handling adaptation capabilities at a generic level are required. This paper introduces the front-end of such a means by describing an approach for analysis and specification of features that vary as a part of reconfigurations at runtime.
---
paper_title: A feature-oriented approach to developing dynamically reconfigurable products in product line engineering

paper_content:

Dynamic product reconfiguration refers to making changes to a deployed product configuration while a system is running. Recently, there have been increasing demands for dynamic product reconfiguration in various application areas (e.g., ubiquitous computing, self-healing systems, etc.); however, most product line engineering methods in the literature have focused on the development of reusable core assets for statically configured products. In this paper, we propose a feature-oriented approach to develop dynamically reconfigurable core assets. This approach takes feature binding analysis results as a key design driver for identifying and managing variation points of dynamically reconfigurable products. We also provide a conceptual model for a reconfigurator, which monitors and manages product reconfiguration at run time. The method is illustrated with a home service robot product line example.
---
paper_title: Adding variants on-the-fly: Modeling meta-variability in dynamic software product lines

paper_content:

Dynamic software product lines (DSPL) are software product lines (SPL) that support runtime variability. Runtime variability is typically interpreted as binding variation points at runtime. We emphasize meta-variability as an important dimension of runtime variability in DSPL. Whereas dynamic binding considers the runtime (de)activation of variants within the scope of a given variability model, meta-variability considers runtime changes to the variability model itself. Meta-variability is essential to support longlived software products that are subject to evolution. In this paper, we consider meta-variability in an industrial DSPL that is developed in a joint project with Egemin N.V., a leading company that provides full life cycle support for automated transportation systems (ATS). The contribution of this paper is threefold. First, we introduce a way to model meta-variability in DSPL in an explicit manner. Second, we put forward a meta-variability meta model that extends the variability meta model with concepts that explicitly support meta-variability. Third, we capture and apply metavariability in an industrial DSPL for automated transportation systems.
---
paper_title: Using Feature Diagrams with Context Variability to Model Multiple Product Lines for Software Supply Chains

paper_content:

Feature modeling is a key concept in product line engineering. Due to the large number of different features and relations in practice, feature models often become too complex to deal with. One of these complexities is caused by the need to support multiple product lines. In this paper we introduce the concept of a context variability model, which contain the primary drivers for variation, e.g. different geographic regions. The context variability model constrains the feature model, which makes it possible to model multiple product lines supporting several dimensions in the context space. We will discuss how this concept can support software supply chains. Here it can be used to facilitate the process of merging feature models during staged configuration. Our initial experimental results indicate that the approach is intuitive and straightforward to use, and can be applied with commercially available variability management tools.
---
paper_title: Rainbow: architecture-based self-adaptation with reusable infrastructure

paper_content:

While attractive in principle, architecture-based self-adaptation raises a number of research and engineering challenges. First, the ability to handle a wide variety of systems must be addressed. Second, the need to reduce costs in adding external control to a system must be addressed. Our rainbow framework attempts to address both problems. By adopting an architecture-based approach, it provides reusable infrastructure together with mechanisms for specializing that infrastructure to the needs of specific systems. The specialization mechanisms let the developer of self-adaptation capabilities choose what aspects of the system to model and monitor, what conditions should trigger adaptation, and how to adapt the system.
---
paper_title: Facets of Adaptivity

paper_content:

Adaptivity is one of the key requirements of today's information systems. It is used in various areas which may range from control and operating systems to networks, from robotics to intelligent systems, from multimedia to information retrieval and Web Services. Essentially, it is related to changes performed in the systems at run-time. These changes may regard various aspects: architectural, structural, behavioral or content. Considering the diversity of its application areas and of ways of achievement, this paper aims to discuss the facetsof adaptivity by raising the following questions: Why is it needed? Which are its objectives? Which are its main open research issues?
---
paper_title: Using Architectural Models to Manage and Visualize Runtime Adaptation

paper_content:

The architectural runtime configuration management approach provides an accurate model of adaptive software system behavior over time. ARCM improves the visibility and understandability of runtime adaptive processes while allowing human input into the adaptation-control loop.
---
paper_title: Product derivation for solution-driven product line engineering

paper_content:

Replica correlation processing, and associated representative signal-data reduction and reconstruction techniques, are used to detect signals of interest and obtain robust measures of received-signal parameters, such as time differences of signal arrival and directional angles of arrival, that can be used to estimate the location of a cellularized-communications signal source. The new use in the present invention of signal-correlation processing for locating communications transmitters. This enables accurate and efficient extraction of parameters for a particular signal even in a frequency band that contains multiple received transmissions, such as occurs with code-division-multiple-access (CDMA) communications. Correlation processing as disclosed herein further enables extended processing integration times to facilitate the effective detection of desired communications-signal effects and replication measurement of their location-related parameters, even for the communications signals modulated to convey voice conversations or those weakened through propagation effects. Using prior, constructed, signal replicas in the correlation processing enables elimination of the inter-site communications of the signal representations that support the correlation analyses. Reduced-data representations of the modulated signals for voiced conversation, or for the variable components of data communications, are used to significantly reduce the inter-site communications that support the correlation analyses.
---
paper_title: Integrated Product Line Model for Semi-Automated Product Derivation Using Non-Functional Properties

paper_content:

A laminated structure suitable for use for the interior decorating of buildings and for motor vehicle upholstery comprising at least one decorative layer of organic material, which is combined, by hot pressing, with a support consisting of a polyolefin sheet, in which the polyolefin sheet comprises from 10 to 90% by weight of cellulose fibres and from 90 to 10% by weight of a polyolefin which is modified by polar monomeric units derived from at least one monomer chosen from the group consisting of unsaturated carboxylic acids, the corresponding anhydrides and derivatives thereof.
---
paper_title: Integrating Automated Product Derivation and Individual User Interface Design

paper_content:

Software Product Lines, in conjunction with model- driven product derivation, are successful examples for extensive automation and reuse in software development. However, often each single product requires an individual, tailored user interface of its own to achieve the desired usability. Moreover, in some cases (e.g., online shops, games) it is even mandatory that each product has an individual, unique user interface of its own. Usually, this results in manual user interface design independent from the model-driven product derivation. Consequently, each product configuration has to be mapped manually to a corresponding user interface which can become a tedious and error-prone task for large and complex product lines. This paper addresses this problem by integrating concepts from SPL product derivation and Model-based User Interface Development. This facilitates both (1) a systematic and semi-automated creation of user interfaces during product derivation while (2) still supporting for individual, creative design.
---
paper_title: Tailoring dynamic software product lines

paper_content:

Software product lines (SPLs) and adaptive systems aim at variability to cope with changing requirements. Variability can be described in terms of features, which are central for development and configuration of SPLs. In traditional SPLs, features are bound statically before runtime. By contrast, adaptive systems support feature binding at runtime and are sometimes called dynamic SPLs (DSPLs). DSPLs are usually built from coarse-grained components, which reduces the number of possible application scenarios. To overcome this limitation, we closely integrate static binding of traditional SPLs and runtime adaptation of DSPLs. We achieve this integration by statically generating a tailor-made DSPL from a highly customizable SPL. The generated DSPL provides only the runtime variability required by a particular application scenario and the execution environment. The DSPL supports self-configuration based on coarse-grained modules. We provide a feature-based adaptation mechanism that reduces the effort of computing an optimal configuration at runtime. In a case study, we demonstrate the practicability of our approach and show that a seamless integration of static binding and runtime adaptation reduces the complexity of the adaptation process.
---
paper_title: Designing runtime variation points in product line architectures: Three cases

paper_content:

Software product lines provide a common architecture, reusable code, and other common assets for a set of related software products. Variation is a central requirement in this context, as the product line components have to be instantiated, composed, and configured in the context of the products. In many approaches either static composition techniques or dynamic composition techniques based on loose relationships, such as association, aggregation, and replacement of entities, are proposed to design the variation points. If the domain of the product requires runtime variation, however, these approaches do not provide any central management facility for the runtime variation points. As a solution to this problem, we propose a pattern language that provides a domain-specific variation language and runtime variation point management facilities as part of the product line. We present three case studies from the areas of interactive digital television and document archiving in which we have applied this pattern language.
---
paper_title: Feature driven dynamic customization of software product lines

paper_content:

This paper describes a model driven development approach for software product lines based on Web services, in which feature selection drives the dynamic customization of the product line architecture and implementation to derive the application. During product line modeling, feature and their dependencies are described in a feature model. The product line architecture is based around a client/server pattern consisting of user interface objects interacting with Web services. During application engineering, features are selected by the application engineer and used to dynamically customize the product line architecture and implementation.
---
paper_title: Feature-oriented variability management in product line engineering

paper_content:

Features are effective communication “media” among different stakeholders of products or product lines. Hence, feature orientation in analyzing com-monality and variability of product lines is appealing. In this paper, we introduce a feature-oriented ap-proach to explicit modeling and managing variability information of a product line. It takes features as first class entities for controlling variability and enables an organization to exploit commonality and manage vari-ability in both problem and solution space.
---
paper_title: The Promise and Challenge of Runtime Variability

paper_content:

Runtime variability offers a good choice for many systems that experience dynamic changes in their quality and context. Since the advent of software product lines (SPLs) in the 1990s as a successful approach for building multiple, related products, feature models (FMs)-compact representations of all the features of the products in the SPL-have increased in popularity. Large and medium- size software companies now rely on numerous second-generation SPL tools such as Gears SPL Lifecycle Framework (www.biglever.com) and pure::variants (www.pure-systems, com) that use FMs to describe the variability of their products. Today, systems with adaptive and context-aware architectures- including autonomic and ubiquitous computing systems and software ecosystems-require more dynamic capabilities to address runtime needs (S. Hallsteinsen et al., "Dynamic Software Product Lines," Computer, Apr. 2008, pp. 93-95). In service-oriented computing, for example, the selection of services motivated by changing conditions or service-level agreements implies an automated binding of the current service to a different one. Likewise, autonomous software designed to load a new system configuration, based on a set of allowed choices, must cope with different situations. Such systems must be able to adapt to runtime conditions and manage them with minimal human intervention.
---
paper_title: Adding Standardized Variability to Domain Specific Languages

paper_content:

We show how a common language of variability can be used to enhance the expressiveness of a domain specific language (DSL). DSLs have been proposed as a mechanism for expressing variability. Variability between models in a given domain or of a family of systems is captured by language constructs, implying that all possible models in this language are the allowed variations. We explore the possibility of expressing variability in a language independently of the base modeling language. We explore how this works for small DSLs as well as for general purpose languages like UML. Implications of this approach are that the variability language can be standardized, and that DSLs do not have to include variability mechanisms.
---
paper_title: Development and adaptation of IEC 61499 automation and control applications with runtime variability models

paper_content:

Developers maintaining distributed control systems are facing significant problems when dealing with changing customer requirements during the development and operation of industrial production facilities. Research has so far largely focused on implementation-level engineering challenges. Model-driven approaches are seen as promising for dealing with the increasing complexity of adapting distributed control systems. We present an approach for capturing architectural variability of distributed IEC 61499 automation and control systems based on product line variability models. Our automated approach supports decision-driven derivation and adaptation of systems at runtime.
---
paper_title: Adding variants on-the-fly: Modeling meta-variability in dynamic software product lines

paper_content:

Dynamic software product lines (DSPL) are software product lines (SPL) that support runtime variability. Runtime variability is typically interpreted as binding variation points at runtime. We emphasize meta-variability as an important dimension of runtime variability in DSPL. Whereas dynamic binding considers the runtime (de)activation of variants within the scope of a given variability model, meta-variability considers runtime changes to the variability model itself. Meta-variability is essential to support longlived software products that are subject to evolution. In this paper, we consider meta-variability in an industrial DSPL that is developed in a joint project with Egemin N.V., a leading company that provides full life cycle support for automated transportation systems (ATS). The contribution of this paper is threefold. First, we introduce a way to model meta-variability in DSPL in an explicit manner. Second, we put forward a meta-variability meta model that extends the variability meta model with concepts that explicitly support meta-variability. Third, we capture and apply metavariability in an industrial DSPL for automated transportation systems.
---
paper_title: Feature-Oriented Domain Analysis (FODA) Feasibility Study

paper_content:

Abstract : Successful Software reuse requires the systematic discovery and exploitation of commonality across related software systems. By examining related software systems and the underlying theory of the class of systems they represent, domain analysis can provide a generic description of the requirements of that class of systems and a set of approaches for their implementation. This report will establish methods for performing a domain analysis and describe the products of the domain analysis process. To illustrate the application of domain analysis to a representative class of software systems, this report will provide a domain analysis of window management system software.
---
paper_title: Automated Diagnosis of Feature Model Configurations

paper_content:

Software product-lines (SPLs) are software platforms that can be readily reconfigured for different project requirements. A key part of an SPL is a model that captures the rules for reconfiguring the software. SPLs commonly use feature models to capture SPL configuration rules. Each SPL configuration is represented as a selection of features from the feature model. Invalid SPL configurations can be created due to feature conflicts introduced via staged or parallel configuration or changes to the constraints in a feature model. When invalid configurations are created, a method is needed to automate the diagnosis of the errors and repair the feature selections. This paper provides two contributions to research on automated configuration of SPLs. First, it shows how configurations and feature models can be transformed into constraint satisfaction problems to automatically diagnose errors and repair invalid feature selections. Second, it presents empirical results from diagnosing configuration errors in feature models ranging in size from 100 to 5,000 features. The results of our experiments show that our CSP-based diagnostic technique can scale up to models with thousands of features.
---
paper_title: Design-time product line architectures for any-time variability

paper_content:

Most solutions for introducing variability in a software system are singular: they support one particular point in the software life cycle at which variability can be resolved to select a specific instance of the system. The presence of significantly increased and dissimilar levels of variability in today's software systems requires a flexible approach that supports selection of a system instance at any point in the life cycle--from statically at design time to dynamically at run time. This paper introduces our approach to supporting any-time variability, an approach based on the ubiquitous use of a product line architecture as the organizing abstraction throughout the lifetime of a software system. The product line architecture specifies the variabilities in a system, both in terms of space (captured as explicit variation points) and time (captured as explicit versions of architectural elements). A system instance can be selected at any point in time by providing a set of desired features, expressed as name-value pairs, to an automated selector tool. We introduce our overall approach, discuss our representation and tools for expressing and managing variability, and demonstrate their use with three representative examples of any-time variability.
---
paper_title: Using Constraint Programming to Manage Configurations in Self-Adaptive Systems

paper_content:

Combining goal-modeling techniques with constraint programming provides the means to identify the variants best suited to the environmental contexts that a self-adaptive software system might encounter at runtime.
---
paper_title: Engineering Service-Based Dynamic Software Product Lines

paper_content:

A service-oriented approach that combines feature-oriented analysis with a self- managing quality-of-service framework addresses the challenges associated with dynamic software product lines.
---
paper_title: Dynamic Software Product Lines for Service-Based Systems

paper_content:

Ageing populations and the necessity to reduceenvironmental impact raise new challenges on our living buildings.Convergence of home control systems (air conditioning,light management) and computer science, or house automation,allows to enhance comfort, security and health of inhabitants,and reduce energy consumption. Each of these abilities can beperceived as a service provided by the house automation system.Starting from this point, we developed ENTIMID , a middlewareable to make systems from different brands cooperate in a singleservice-based platform. Yet the proliferation and variability ofsuch services, and needs to tailor each system to a particularbuilding, make the design of these systems complex. In thisprospective paper, we explain how the notion of dynamic softwareproduct line facilitates such designs by providing sophisticatedtechniques for managing variability across services from designtime to runtime and allowing their automatic composition.
---
paper_title: Dynamic software product line architectures using service based computing for automotive systems

paper_content:

Our research is aimed at applying the notion of dynamic runtime variability of software product lines in the embedded automotive software systems to create adaptable and reconfigurable software architectures. We argue that Service-Oriented Architecture (SOA) can be used to describe and compose the software architecture of an in-vehicle Distributed Real-time Embedded System (DRES) software application. This paper describes how the SOA is, in general, an appropriate architectural style for automotive DRES and in particular it has the potential to help achieve the run time variability in product line architectures. The architecture of such a product line is composed of a set of interacting services. These services are “adaptively” connected together with adaptive connectors. The variability of the product line architecture lies and managed within these connectors.
---
paper_title: Context Awareness for Dynamic Service-oriented Product Lines

paper_content:

This paper presents a Context-Aware Dynamic Software Product Line (DSPL) for building service oriented applications and adapting them at runtime in accordance with their using context. This DSPL, named CAPucine for Context-Aware Service-Oriented Product Line is based on two different processes for product derivation. The first process uses assets that represent features of the product family. The assets, represented as models, get composed and transformed in order to generate the product. The second process relates to dynamic adaptation. This process introduces context-aware assets that operate at runtime. These context-aware assets contain three kinds of data: the context when the assets can be modified, the place where the assets must be applied and the change that must be performed. The realization of these context-aware assets combines two runtime platforms. On the one hand,COSMOS is a context-aware framework connected to the environment by the use of sensors. On the other hand FraSCAti is a Service Component Architecture (SCA) platform with dynamic properties that enables to bind and unbind components at runtime. CAPucine allows designing and processing context-aware applications based on an SCA platform which is dynamic, introspectable, and reconfigurable in accordance with the context environment.
---
paper_title: Dynamic software adaptation for service-oriented product lines

paper_content:

This paper describes a dynamic software adaptation approach and environment for service-oriented product lines. The approach uses a dynamic feature model and product line architecture for a family of service-oriented architectures (SOA), in which a member of the SOA can be dynamically adapted to a different member of the family at run-time. The approach integrates software product line and feature modeling concepts with SOA and dynamic software adaptation concepts. The approach is validated using a case study of a dynamic service-oriented product line.
---
paper_title: Performance property prediction supporting variability for adaptive mobile systems

paper_content:

A performance property prediction (PPP) method for component-based self-adaptive applications is presented. Such performance properties are required by an adaptation middleware for reasoning about adaptation activities. Our PPP method is based on the Structure and Performance (SP) framework, a conceptually simple, yet powerful performance modelling framework based on matrices. The main contribution of this paper are the integration of SP-based PPP into a comprehensive model- and variability-based adaptation framework for context-aware mobile applications. A meta model for the SP method is described. The framework is demonstrated using a practical example.
---
paper_title: Automating Product-Line Variant Selection for Mobile Devices

paper_content:

Product-line architectures (PLAs) designed for mobile devices create a unique challenge for automated product variant selection engines since variants must be derived on-the-fly as devices are discovered. Current automation techniques do not incorporate device resource consumption constraints into variant selection and do not address how a PLA can be designed to improve automated variant selection speed. This paper presents a tool called Scatter whose input is (1) the requirements of PLA construction and (2) the resources available on a discovered mobile device and whose output is the optimal variant that can be deployed to the device. Scatter provides automatic variant selection based on configuration and resource constraints and also ensures that variant selection is optimal with regard to a configurable cost function. The paper presents our results from experiments with Scatter and how PLA design decisions affect a constraint-based variant selection engine's solving speed.
---
paper_title: From software product lines to software ecosystems

paper_content:

Software product line companies increasingly expand their platform outside their organizational boundaries, in effect transitioning to a software ecosystem approach. In this paper, we discuss the emerging trend of software ecosystems and provide a overview of the key concepts and implications of adopting a software ecosystem approach. We define the notion of software ecosystems and introduce a taxonomy. Finally, we explore the implications of software ecosystems to the way companies build software.
---
paper_title: Designing and managing evolving systems using a MAS product line approach

paper_content:

We view an evolutionary system as being a software product line. The core architecture is the unchanging part of the system, and each version of the system may be viewed as a product from the product line. Each ''product'' may be described as the core architecture with some agent-based additions. The result is a multiagent system software product line. We describe an approach to such a software product line-based approach using the MaCMAS agent-oriented methodology. The approach scales to enterprise architectures as a multiagent system is an appropriate means of representing a changing enterprise architecture and the interaction between components in it. In addition, we reduce the gap between the enterprise architecture and the software architecture.
---

Title: An overview of Dynamic Software Product Line architectures and techniques: Observations from research and industry

Section 1: Introduction
Description 1: Present the background and motivation for adopting Dynamic Software Product Lines (DSPLs), highlighting the limitations of conventional SPLs and the need for runtime adaptability.

Section 2: Target audience and summary of contributions
Description 2: Identify the target audience for the paper and summarize the main contributions and key aspects covered in the work.

Section 3: Related work
Description 3: Review existing literature and efforts related to DSPLs, focusing on the gaps and the need for dynamic variability mechanisms at runtime.

Section 4: Runtime variability techniques
Description 4: Explore the techniques and models proposed for supporting dynamic variability, including runtime transformations and context-aware properties.

Section 5: Contextual Information
Description 5: Discuss the role of context information in DSPLs and how contextual variability can be modeled and managed dynamically.

Section 6: A framework for DSPL characterization
Description 6: Introduce a framework for characterizing DSPLs, detailing the properties required, organizational changes compared to conventional SPLs, and runtime variability solutions.

Section 7: The role and challenges of runtime variability
Description 7: Outline the significance of runtime variability in DSPLs and describe the challenges and technical aspects involved in implementing such mechanisms.

Section 8: A runtime variability model
Description 8: Present the basic elements and structure of a runtime variability model, specifying how it addresses the challenges identified for DSPLs.

Section 9: Characterization of runtime variability
Description 9: Detail specific solutions to represent and manage runtime variability, focusing on structural changes and handling dynamic features.

Section 10: Runtime variability management
Description 10: Discuss approaches to manage and check feature models at runtime, ensuring the validity of configurations and dependencies.

Section 11: Runtime binding and re-binding
Description 11: Address the concepts of multiple binding times and re-binding capabilities, providing solutions for dynamic and context-aware product configurations.

Section 12: Context variability for adaptation purposes
Description 12: Provide a framework to manage context-aware features, linking them to reconfiguration strategies to support adaptive behavior in DSPLs.

Section 13: Dynamic and optimized reconfiguration
Description 13: Discuss techniques for dynamic reconfiguration and optimization, focusing on satisfying user preferences and quality attributes in mission-critical systems.

Section 14: Application domains
Description 14: Illustrate the applicability and benefits of DSPLs in various domains such as service-oriented systems, mobile software, ecosystems, and autonomous systems.

Section 15: Discussion
Description 15: Reflect on the proposed solutions, discussing their effectiveness, limitations, and the current maturity of DSPL technologies.

Section 16: Conclusions and future work
Description 16: Summarize the key findings and contributions of the paper, and suggest directions for future research in the field of DSPLs.