Abstract. Although a feature model can represent commonalities and variabilities in a very concise taxonomic form, features in a feature model are merely symbols. Mapping features to other models, such as behavioral or data specifications, gives them semantics. In this paper, we propose a general template-based approach for mapping feature models to concise representations of variability in different kinds of other models. We show how the approach can be applied to UML 2.0 activity and class models and describe a prototype implementation. 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. Current software systems increasingly consist of distributed interacting components. The use of web services and similar middleware technologies strongly fosters such architectures. The complexity resulting from a high degree of interaction between distributed components – that we face with web service orchestration for example – poses severe problems. A promising approach to handle this intricacy is service-oriented development; in particular with a domain-unspecific service notion based on interaction patterns. Here, a service is defined by the interplay of distributed system entities, which can be modeled using UML Sequence Diagrams. However, we often face functionality that affects or is spanned across the behavior of other services; a similar concept to aspects in Aspect-Oriented Programming. In the service-oriented world, such aspects form crosscutting services. In this paper we show how to model those; we introduce aspect-oriented modeling techniques for UML Sequence Diagrams and show their usefulness by means of a running example. 1

However, permission to reprint/republish this material for advertising or promotional purposes or for creating new collective works for resale or redistribution to servers or lists, or to reuse any copyrighted component of this work in other works must be obtained from the IEEE.

Abstract—Customizable programs and program families provide user-selectable features to allow users to tailor a program to an application scenario. Knowing in advance which feature selection yields the best performance is difficult because a direct measurement of all possible feature combinations is infeasible. Our work aims at predicting program performance based on selected features. However, when features interact, accurate predictions are challenging. An interaction occurs when a particular feature combination has an unexpected influence on performance. We present a method that automatically detects performance-relevant feature interactions to improve prediction accuracy. To this end, we propose three heuristics to reduce the number of measurements required to detect interactions. Our evaluation consists of six real-world case studies from varying domains (e.g., databases, encoding libraries, and web servers) using different configuration techniques (e.g., configuration files and preprocessor flags). Results show an average prediction accuracy of 95 %. I.

Ubiquitous computing increases the pressure on the software industry to produce ever more and error-free code. As an answer, generative programming increases the level of abstraction in software development by describing problems in high-level domain-specific languages and translating these to executable code. AHEAD (Algebraic Hierarchical Equations for Application Design) is a framework for generative programming that achieves additional productivity gains by recognizing that in many areas, we need a family of programs that are very similar. It avoids duplication of work by generating programs out of a common base of features that can be freely composed. Our contribution is Graft, a calculus that gives a formal foundation to AHEAD and provides several mechanisms for making sure that feature combinations are legal and that features in themselves are consistent. 1

I hereby declare that the work presented in this thesis is my own original work unless otherwise indicated in the text, and that it has not been submitted for any other degree or award. Where work presented in this thesis appears in publications of which I am a named author, references are indicated in the text. In particular, I note the following contributions from others: • The ACCENT policy system and APPEL policy language discussed in Chapter 3 was used as a basis for the extensions and tools presented in this thesis. The original authors were Stephan Reiff-Marganiec, Lynne Blair, Kenneth J. Turner and Jianxiong Pang. • The approach to policy conflict filtering presented in Chapter 5 was research proposed by my supervisor Kenneth J. Turner. My contribution was to develop the ontology and tool support to implement and apply the approach. • The goal-directed approach presented in Chapter 6 evolved through collaboration with my supervisor Kenneth J. Turner. Gavin A. Campbell

Telecommunication services vary greatly in their behavior. However they often can be decomposed into tightly-focused components, each designed to accomplish a certain limited function. In some cases, these functions are repeated across many services that seem quite disparate at first glance. We examine some components that have proven to be highly reusable, and demonstrate how they can be composed into a variety of interesting services.

The ever growing size and complexity of both technical and business systems requires efficient software engineering approaches to keep development cost under control while still being able to finish development efforts in time with the required functionality and quality. Systematic software and systems engineering approaches help to push the boundary further and leverage the complexity on many different levels. On the one hand, the availability of appropriate models and notations for the systems under development throughout the development cycle and for all levels of abstraction helps to understand and modify manageable views of the system. On the other hand, systematic development processes can provide the harness for successful project execution and for the ability to repeatedly create results that meet the required quality standards and functionality within the budgeted cost and time. In this paper we combine a proven generic project management framework with a methodology for developing complex multi-functional systems. We embed our service-oriented development approach for reactive systems into the system development process model V-Modell XT by providing a modular extension of the V-Modell XT for service-oriented development. We introduce our development approach by means of a running example from the complex control systems domain, the BART traffic controller example.