Model transformations are touted to play a key role in Model Driven Developmente. Although well-established standards for creating metamodels such as the Meta-Object Facility exist, there is currently no mature foundation for specifying transformations among models. We propose a framework for the classification of several existing and proposed model transformation approaches. The classification framework is given as a feature model that makes explicit the different design choices for model transformations. Based on our analysis of model transformation approaches, we propose a few major categories in which most approaches fit.

Two programming paradigms are gaining attention in the overlapping fields of software product lines (SPLs) and incremental software development (ISD). Feature-oriented programming (FOP) aims at large-scale compositional programming and feature modularity in SPLs using ISD. Aspect-oriented programming (AOP) focuses on the modularization of crosscutting concerns in complex software. Although feature modules, the main abstraction mechanisms of FOP, perform well in implementing large-scale software building blocks, they are incapable of modularizing certain kinds of crosscutting concerns. This weakness is exactly the strength of aspects, the main abstraction mechanisms of AOP. We contribute a systematic evaluation and comparison of FOP and AOP. It reveals that aspects and feature modules are complementary techniques. Consequently, we propose the symbiosis of FOP and AOP and aspectual feature modules (AFMs), a programming technique that integrates feature modules and aspects. We provide a set of tools that support implementing AFMs on top of Java and C++. We apply AFMs to a nontrivial case study demonstrating their practical applicability and to justify our design choices.

Superimposition is a composition technique that has been applied successfully in many areas of software development. Although superimposition is a general-purpose concept, it has been (re)invented and implemented individually for various kinds of software artifacts. We unify languages and tools that rely on superimposition by using the language-independent model of feature structure trees (FSTs). On the basis of the FST model, we propose a general approach to the composition of software artifacts written in different languages, Furthermore, we offer a supporting framework and tool chain, called FEATUREHOUSE. We use attribute grammars to automate the integration of additional languages, in particular, we have integrated Java, C#, C, Haskell, JavaCC, and XML. Several case studies demonstrate the practicality and scalability of our approach and reveal insights into the properties a language must have in order to be ready for superimposition. 1.

Abstract—A software product line (SPL) is an efficient means to generate a family of program variants for a domain from a single code base. However, because of the potentially high number of possible program variants, it is difficult to test all variants and ensure properties like type-safety for the entire SPL. While first steps to type-check an entire SPL have been taken, they are informal and incomplete. In this paper, we extend the Featherweight Java (FJ) calculus with feature annotations to be used for SPLs. By extending FJ’s type system, we guarantee that – given a well-typed SPL – all possible program variants are welltyped as well. We show how results from this formalization reflect and help implementing our own language-independent SPL tool CIDE. I.

Abstract. Superimposition is a composition technique that has been applied successfully in several areas of software development. In order to unify several languages and tools that rely on superimposition, we present an underlying language-independent model that is based on feature structure trees (FSTs). Furthermore, we offer a tool, called FST-Composer, that composes software components represented by FSTs. Currently, the tool supports the composition of components written in Java, Jak, XML, and plain text. Three nontrivial case studies demonstrate the practicality of our approach. 1

Abstract Nowadays, process oriented software systems, like many business information systems, don’t exist only in one single version, but in many variants for better coverage of the target market. Until now, the corresponding customization has to be done manually, which is a timeconsuming and error-prone task, which could be realized much more efficient by applying process family engineering techniques. Process family engineering is a modern software development approach, which allows for the rapid and cost-effective development and deployment of customer tailored process oriented systems. In this paper we present our findings in the area of process family architectures for e-business systems, described as variant-rich process models in the Business Process Modeling Notation. We moreover tackle variability implementation issues using Java variability mechanisms and code generators. The presentation of our findings is oriented to a case study for the validation of our process family engineering concepts developed in the context of the research project PESOA. 1

Abstract. Workflow modelling languages allow for the specification of executable business processes. They, however, do typically not provide any guidance for the adaptation of workflow models, i.e. they do not offer any methods or tools explaining and highlighting which adaptations of the models are feasible and which are not. Therefore, an approach to identify so-called configurable elements of a workflow modelling language and to add configuration opportunities to workflow models is presented in this paper. Configurable elements are the elements of a workflow model that can be modified such that the behavior represented by the model is restricted. More precisely, a configurable element can be either set to activated, to blocked, or to hidden. To ensure that such configurations lead only to desirable models, our approach allows for imposing so-called requirements on the model’s configuration. They have to be fulfilled by any configuration, and limit therefore the freedom of configuration choices. The identification of configurable elements within the workflow modelling language of YAWL and the derivation of the new “configurable YAWL ” language provide a concrete example for a rather generic approach. A transformation of configured models into lawful YAWL models demonstrates its applicability. 1

Software-product-line engineering is an efficient means to generate a family of program variants for a domain from a single code base. However, because of the potentially high number of possible program variants, it is difficult to test them all and ensure properties like type safety for the entire product line. We present a product-line–aware type system that can type check an entire software product line without generating each variant in isolation. Specifically, we extend the Featherweight Java calculus with feature annotations for product-line development and prove formally that all program variants generated from a well-typed product line are well-typed. Furthermore, we present a solution to the problem of typing mutually exclusive features. We discuss how results from our formalization helped implementing our own product-line tool CIDE for full Java and report of experience with detecting type errors in four existing software-product-line implementations.

Feature modeling has been proposed as an approach for describing variable requirements for software product lines. In this paper, we explore the relationship between feature models and ontologies. First, we examine how previous extensions to basic feature modeling move it closer to richer formalisms for specifying ontologies such as MOF and OWL. Then, we explore the idea of feature models as views on ontologies. Based on that idea, we propose two approaches for the combined use of feature models and ontologies: view derivation and view integration. Finally, we give some ideas about tool support for these approaches. 1

Model-driven software development improves the way software is developed by capturing key features of the system in models which are developed and refined as the system is created. During the system’s lifecycle models are combined and transformed between different levels of abstraction and viewpoints. Aspectoriented techniques improve software development by providing modularization constructs for the encapsulation of crosscutting concerns. Existing research has already investigated many ways of combining the two paradigms. This paper contributes by presenting XWeave, a model weaver that supports weaving of both models and meta models. XWeave supports the composition of different architectural viewpoints and eases model evolution. Furthermore, the tool plays an important role in software product line engineering, as variable parts of architectural models can be woven according to some product configuration. The concepts are illustrated with an example of a home automation system.