Benjamin Behringer

Integrating feature-based implementation approaches using a common graph-based representation

Based on the structured document algebra, we propose the model of structured document graphs: a common, generic graph-based representation for compositional and annotative feature implementations. The core elements in the graph are modules that allow adding, removing and replacing feature details in a fine-granular fashion. To show the feasibility and generality of our model, we prototypically implemented our concepts and imported five FeatureHouse examples (written in Java) and three CIDE projects (written in Java, Haskell and HTML) into our prototype. To test the validity of the resulting graph, we randomly produced different products, semi-automatically compared our results to the ones produced by the original tool, and found no semantic differences. As a result, our model lays the foundation for projections that allow moving fluidly between compositional, annotative and mixed versions of the product line.

Integrating approaches for feature implementation

Compositional and annotative approaches are two competing yet complementary candidates for implementing feature-oriented software product lines. While the former provides real modularity, the latter excels concerning expressiveness. To combine the respective advantages of compositional and annotative approaches, we aim at unifying their underlying representations by leveraging the snippet system instead of directories and files. In addition, to exploit this unification, we propose different editable views.

Towards Feature-Oriented Fault Tree Analysis

In single product development, FTA is a common risk assessment technique. While several existing variability-aware extensions of FTA depend on the pruning of 150% models of fault trees for final product configuration, this paper proposes a feature-oriented extension of FTA with a stronger focus on the systematic reuse of fault propagation paths instead. We present an approach to create fault tree modules for features and feature interactions, which can be reused for the generation of different valid fault tree variants. As a consequence, the influence of features on hazards can be examined. Moreover, we employ a running example scenario throughout the paper that has been evaluated using a prototypical implementation to illustrate the feasibility of the presented approach.

PEoPL: projectional editing of product lines

The features of a software product line—a portfolio of system variants—can be realized using various implementation techniques (a. k. a., variability mechanisms). Each technique represents the software artifacts of features differently, typically classified into annotative (e.g., C preprocessor) and modular representations (e.g., feature modules), each with distinct advantages and disadvantages. Annotative representations are easy to realize, but annotations clutter source code and hinder program comprehension. Modular representations support comprehension, but are difficult to realize. Most importantly, to engineer feature artifacts, developers need to choose one representation and adhere to it for evolving and maintaining the same artifacts. We present PEoPL, an approach to combine the advantages of annotative and modular representations. When engineering a feature artifact, developers can choose the most-suited representation and even use different representations in parallel. PEoPL relies on separating a product line into an internal and external representation, the latter by providing editable projections used by the developers. We contribute a programming-language-independent internal representation of variability, five editable projections reflecting different variability representations, a supporting IDE, and a tailoring of PEoPL to Java. We evaluate PEoPLs expressiveness, scalability, and flexibility in eight Java-based product lines, finding that all can be realized, that projections are feasible, and that variant computation is fast (

Implementing delta-oriented SPLs using PEoPL: an example scenario and case study

Software product line implementation techniques are complementary. Thus, moving fluidly between them would be beneficial. Our tool PEoPL, a novel instantiation of the MPS language workbench, supports projecting a common variational AST into user-editable projections, each of which represents a different product line implementation technique. PEoPL supports FOP-like, annotative and product projections and allows developers to move fluidly between them. In this paper, we lay the foundation for future delta-oriented projectional editors. We use an example scenario to discuss a mapping of DeltaJ language concepts to the variational AST and operations employed in PEoPL. In a case study, we show that PEoPL is expressive enough to represent DeltaJ product lines, and at the same time supports all delta manipulations.

Separating features using colored snippet graphs

In feature-oriented software product lines, two complementary approaches to implement features exist: compositional and annotative ones. To combine the respective advantages, a unified representation of the two on the file-system level is desirable, yet unavailable. We pick up this demand and propose a novel concept for separating features using colored snippet graphs instead of directories and files. In particular, our proposed ideas are based on snippets, ASTs and coloring, and enable the implementation of product lines with both compositional and annotative views on real documents. As a basis for future tools, we provide a conceptual overview of our approach, discuss our ideas for leveraging snippets, and demonstrate applicability using an example scenario.

Towards Frame-based Source Code Generation for Heterogeneous Real-time Environments

Abstract This work focusses on the source code generation of task and communication patterns for different real-time operating systems. On the basis of reusable frames, an initial approach for implementing distributed applications will be presented. Thereby, distributed real-time systems can be mapped to the operating system framework Hyper Real-time Operating System (HyROS). In this respect, it is of great importance to cleanly separate functional from non-functional properties. Mapping different systems to HyROS can be achieved by using HyFrameLang, a language for frame operations and HyAppLang, an embedded domain specific language. Programming examples for HyFrameLang and HyAppLang are presented for task patterns of PXROS-HR and OSEK/VDX, representative real-time operating systems. Moreover, a short introduction on framing communication aspects is given.

Multi-view editing of software product lines with PEoPL

A software product line is a portfolio of software variants in an application domain. It relies on a platform integrating common and variable features of the variants using variability mechanisms— typically classified into annotative and compositional mechanisms. Annotative mechanisms (e.g., using the C preprocessor) are easy to apply, but annotations clutter source code and feature code is often scattered across the platform, which hinders program comprehension and increases maintenance effort. Compositional mechanisms (e.g., using feature modules) support program comprehension and maintainability by modularizing feature code, but are difficult to adopt. Most importantly, engineers need to choose one mechanism and then stick to it for the whole life cycle of the platform. The PEoPL (Projectional Editing of Product Lines) approach combines the advantages of both kinds of mechanisms. In this paper, we demonstrate the PEoPL IDE, which supports the approach by providing various kinds of editable views, each of which represents the same software product line using annotative or compositional variability mechanisms, or subsets of concrete variants. Software engineers can seamlessly switch these views, or use multiple views side-by-side, based on the current engineering task. A demo video of PEoPL is available at Youtube: https://youtu.be/wByUxSPLoSY