Andreas Pleuss

Model-driven development of advanced user interfaces

The workshop on model-driven development of advanced user interfaces will be a forum of multi-disciplinary discussion on how to integrate model-driven development with the often more informal methodologies used in user-centered design. Starting point of the discussion will be the tools, models, methods and experiences of the workshop participants.

Model-driven support for product line evolution on feature level

Highlights? We model the evolution of a product line on feature model level. ? Our approach supports both modeling of historic evolution and proactively planning of future evolution. ? The initial evolution model can be derived automatically from a given sequence of feature model versions. ? After planning future evolution using the evolution model, the resulting feature models can be generated automatically. ? The evolution model provides a foundation for automated analyses and interactive tools. Software Product Lines (SPL) are an engineering technique to efficiently derive a set of similar products from a set of shared assets. In particular in conjunction with model-driven engineering, SPL engineering promises high productivity benefits. There is however, a lack of support for systematic management of SPL evolution, which is an important success factor as a product line often represents a long term investment. In this article, we present a model-driven approach for managing SPL evolution on feature level. To reduce complexity we use model fragments to cluster related elements. The relationships between these fragments are specified using feature model concepts itself leading to a specific kind of feature model called EvoFM. A configuration of EvoFM represents an evolution step and can be transformed to a concrete instance of the product line (i.e., a feature model for the corresponding point in time). Similarly, automatic transformations allow the derivation of an EvoFM from a given set of feature models. This enables retrospective analysis of historic evolution and serves as a starting point for introduction of EvoFM, e.g., to plan future evolution steps.

Knowledge management in software ecosystems: software artefacts as first-class citizens

Collaborative development of software products across organisational boundaries in software ecosystems adds new challenges to existing software engineering processes. We propose a new approach for handling the diverse software artefacts in ecosystems by adapting features from social network sites. We promote artefacts to first-class citizens in such networks and specify different types of relationships between artefacts and actors. This helps in detaching tacit knowledge from vendors, suppliers, developers and users of an ecosystem and fosters easier management of software artefacts. We discuss this by example scenarios and present a prototypic implementation.

Evolution of Software Product Lines

A Software Product Line (SPL) aims to support the development of a family of similar software products from a common set of shared assets. SPLs represent a long-term investment and have a considerable life-span. In order to realize a return-on-investment, companies dealing with SPLs often plan their product portfolios and software engineering activities strategically over many months or years ahead. Compared to single system engineering, SPL evolution exhibits higher complexity due to the variability and the interdependencies between products. This chapter provides an overview on concepts and challenges in SPL evolution and summarizes the state of the art. For this we first describe the general process for SPL evolution and general modeling concepts to specify SPL evolution. On this base, we provide an overview on the state-of-the-art in each of the main process tasks which are migration towards SPLs, analysis of (existing) SPL evolution, planning of future SPL evolution, and implementation of SPL evolution.

User interface engineering for software product lines: the dilemma between automation and usability

Software Product Lines (SPL) are systematic approach to develop families of similar software products by explicating their commonalities and variability, e.g., in a feature model. Using techniques from model-driven development, it is then possible to automatically derive a concrete product from a given configuration (i.e., selection of features). However, this is problematic for interactive applications with complex user interfaces (UIs) as automatically derived UIs often provide limited usability. Thus, in practice, the UI is mostly created manually for each product, which results in major drawbacks concerning efficiency and maintenance, e.g., when applying changes that affect the whole product family. This paper investigates these problems based on real-world examples and analyses the development of product families from a UI perspective. To address the underlying challenges, we propose the use of abstract UI models, as used in HCI, to bridge the gap between automated, traceable product derivation and customized, high quality user interfaces. We demonstrate the feasibility of the approach by a concrete example implementation for the suggested model-driven development process.

Consistency checking for the evolution of cardinality-based feature models

Feature-models (fms) are a widely used approach to specify the commonalities and variability in variable systems and software product lines. Various works have addressed edits to fms for fm evolution and tool support to ensure consistency of fms. An important extension to fms are feature cardinalities and related constraints, as extensively used e.g., when modeling variability of cloud computing environments. Since cardinality-based fms pose additional complexity, additional support for evolution and consistency checking with respect to feature cardinalities would be desirable, but has not been addressed yet. In this paper, we discuss common cardinality-based fm edits and resulting inconsistencies based on experiences with fms in cloud domain. We introduce tool-support for automated inconsistency detection and explanation based on an off-the-shelf solver. We demonstrate the feasibility of the approach by an empirical evaluation showing the performance of the tool.

Model-driven development and evolution of customized user interfaces

One of the main benefits of model-driven development of User Interfaces (UIs) is the increase in efficiency and consistency when developing multiple variants of a UI. For instance, multiple UIs for different target users, platforms, devices, or for whole product families can be generated from the same abstract models. However, purely generated UIs are not always sufficient as there is often need for customizing the individual UI variants, e.g., due to usability issues or specific customer requirements. In this paper we present a model-driven approach for the development of UI families with systematic support for customizations. The approach supports customizing all aspects of a UI (UI elements, screens, navigation, etc.) and storing the customizations in specific models. As a result, a UI family can be evolved more efficiently because individual UI variants can be re-generated (after some changes have been applied to the family) without losing any previously made customizations. We demonstrate this by thirty highly customized real-world products from a commercial family of web information systems called HIS-GX/QIS.

Visualization of variability and configuration options

When designing, constructing, and maintaining diverse and variable software systems, a key challenge is the complexity of systems. A potential approach to tackle this challenge are techniques from variability management and product line engineering to handle the diversity and variability. A key asset in variability management is a variability model, which explicitly specifies the commonalities and variability of a system and the constraints between variants. However, handling variability and configurations remains a challenge due to the complexity on a cognitive level as human engineers reach their limits in identifying, understanding, and using all relevant details. In this paper we address this issue by providing concepts for interactive visual tool support for the configuration of systems with the help of feature models. We discuss relevant principles from the area of information visualization and their application to the domain of feature model configuration. We discuss techniques for interactive configuration support based on a reasoning engine, which, e.g., ensures the validity of configurations. We illustrate our findings by a concrete tool solution called S2T2 Configurator.

Managing complexity and variability of a model-based embedded software product line

This paper presents a framework for model-based product lines of embedded systems. We show how to integrate model-based product line techniques into a consistent framework that can deal with large product lines as they are common in industry. The framework demonstrates the strengths of model-based techniques like abstraction, support for customised representations, and a high degree of automation. In particular, we provide the following contributions: (1) to shift existing product lines towards a model-based approach, we support the (semi-) automated extraction of models from existing requirement, test, and implementation artefacts; (2) to cope with the complexity of artefacts and their interrelations in industrial product lines, we support the generation of context-specific views. These views support developers, e.g., in analysing complex dependencies between different artefacts; (3) finally, we support automated product derivation based on an integrated hardware abstraction layer. Most of the presented concepts have been inspired by challenges arising in the industrial application of product line techniques in the model-based engineering of embedded systems. We report on experiences gathered during the application of the techniques to a prototypical product line (on a rapid prototyping platform in the university lab) and to industrial sample cases (at the industry partner).

Visualization techniques for application in interactive product configuration

In product line engineering (PLE) a major challenge is the complexity of artifacts that have to be handled. In real-world product lines, variability models can become large and complex comprising thousands of elements with hundreds of non-trivial dependencies. Visual and interactive techniques aim to reduce the (cognitive) complexity and support the user during challenging PLE tasks like product configuration. There are many visualization techniques described in the literature -- e.g., in Software Visualization -- and some isolated techniques have been applied in PLE tools. Nevertheless, the full potential of visualization in the context of PLE has not been exploited so far. This paper provides an overview of (1) available visualization techniques and criteria to judge their benefits and drawbacks for product configuration, (2) which have been applied in product configuration in PLE, and (3) which could be beneficial to support product configuration. We propose a research agenda for future work in visual and interactive PLE techniques.