Fakultät für Informatik Arbeitsgruppe Datenbanken
I've moved. See my new web page at the Philipps University of Marburg.

Christian Kästner (Curriculum vitae)

me Otto-von-Guericke-Universität Magdeburg
School of Computer Science
Department of Technical and Business Information Systems
Database and Information Systems Group
P.O. Box 4120, D-39016 Magdeburg, Germany

Office: Building 29, Room 108

Phone: ++49 391 67 11899
Fax:     ++49 391 67 12020
E-mail: kaestner (at) iti.cs.uni-magdeburg.de

Teaching (German)

Sommersemester 2010

Wintersemester 2009/10

Alle Veranstaltungen (Univis-Sicht)
Rahmenbedingungen fuer Software-/Laborpraktika und IT-Projekte: .pdf

Research Interests

  • Virtual Separation of Concerns
  • Feature-oriented software development (FOSD), type systems, refactoring, aspect-orientation, multidimensional separation of concerns
  • Software product lines, program synthesis, program decomposition, feature interactions

Research Projects

Publications

2012

2011

2010

  • Jörg Liebig, Sven Apel, Christian Lengauer, Christian Kästner, and Michael Schulze. An Analysis of the Variability in Forty Preprocessor-Based Software Product Lines. In Proceedings of the 32nd International Conference on Software Engineering (ICSE), New York, NY, USA, May 2010. ACM. 105–114.
    Over 30 years ago, the preprocessor cpp was developed to extend the programming language C by lightweight metaprogramming capabilities. Despite its error-proneness and low abstraction level, the cpp is still widely being used in presentday software projects to implement variable software. However, not much is known about emphhow the cpp is employed to implement variability. To address this issue, we have analyzed forty open-source software projects written in C. Specifically, we answer the following questions: How does program size influence variability? How complex are extensions made via cpp's variability mechanisms? At which level of granularity are extensions applied? What is the general type of extensions? These questions revive earlier discussions on understanding and refactoring of the preprocessor. To answer them, we introduce several metrics measuring the variability, complexity, granularity, and type of extensions. Based on the data obtained, we suggest alternative implementation techniques. The data we have collected can influence other research areas, such as language design and tool support.
  • Christian Kästner. Virtual Separation of Concerns: Toward Preprocessors 2.0. Dissertation, University of Magdeburg, Germany, May 2010.
    Conditional compilation with preprocessors such as cpp is a simple but effective means to implement variability. By annotating code fragments with #ifdef and #endif directives, different program variants with or without these annotated fragments can be created, which can be used (among others) to implement software product lines. Although, such annotation-based approaches are frequently used in practice, researchers often criticize them for their negative effect on code quality and maintainability. In contrast to modularized implementations such as components or aspects, annotation-based implementations typically neglect separation of concerns, can entirely obfuscate the source code, and are prone to introduce subtle errors. Our goal is to rehabilitate annotation-based approaches by showing how tool support can address these problems. With views, we emulate modularity; with a visual representation of annotations, we reduce source code obfuscation and increase program comprehension; and with disciplined annotations and a product-line–aware type system, we prevent or detect syntax and type errors in the entire software product line. At the same time we emphasize unique benefits of annotations, including simplicity, expressiveness, and being language independent. All in all, we provide tool-based separation of concerns without necessarily dividing source code into physically separated modules; we name this approach virtual separation of concerns. We argue that with these improvements over contemporary preprocessors, virtual separation of concerns can compete with modularized implementation mechanisms. Despite our focus on annotation-based approaches, we do intend not give a definite answer on how to implement software product lines. Modular implementations and annotation-based implementations both have their advantages; we even present an integration and migration path between them. Our goal is to rehabilitate preprocessors and show that they are not a lost cause as many researchers think. On the contrary, we argue that – with the presented improvements – annotation-based approaches are a serious alternative for product-line implementation.
  • Christian Kästner, Sven Apel, and Gunter Saake. Virtuelle Trennung von Belangen (Präprozessor 2.0). In Software Engineering 2010 – Fachtagung des GI-Fachbereichs Softwaretechnik, number P-159 in Lecture Notes in Informatics, pages 165–176. Gesellschaft für Informatik (GI), February 2010.
    Bedingte Kompilierung mit Präprozessoren wie cpp ist ein einfaches, aber wirksames Mittel zur Implementierung von Variabilität in Softwareproduktlinien. Durch das Annotieren von Code-Fragmenten mit #ifdef und #endif können verschiedene Programmvarianten mit oder ohne diesen Fragmenten generiert werden. Obwohl Präprozessoren häufig in der Praxis verwendet werden, werden sie oft für ihre negativen Auswirkungen auf Codequalität und Wartbarkeit kritisiert. Im Gegensatz zu modularen Implementierungen, etwa mit Komponenten oder Aspekte, vernachlässigen Präprozessoren die Trennung von Belangen im Quelltext, sind anfällig für subtile Fehler und verschlechtern die Lesbarkeit des Quellcodes. Wir zeigen, wie einfache Werkzeugunterstützung diese Probleme adressieren und zum Teil beheben bzw. die Vorteile einer modularen Implementierung emulieren kann. Gleichzeitig zeigen wir Vorteile von Präprozessoren wie Einfachheit und Sprachunabhängigkeit auf.
  • Friedrich Steimann, Thomas Pawlitzki, Sven Apel, and Christian Kästner. Types and Modularity for Implicit Invocation with Implicit Announcement. ACM Transactions on Software Engineering and Methodology (TOSEM), 20(1), 2010. to appear; submitted March 15, 2008; accepted March 18, 2009.
    Through implicit invocation, procedures are called without explicitly referencing them. Implicit announcement adds to this implicitness by not only keeping implicit which procedures are called, but also where or when – under implicit invocation with implicit announcement, the call site contains no signs of that, or what it calls. Recently, aspect-oriented programming has popularized implicit invocation with implicit announcement as a possibility to separate concerns that lead to interwoven code if conventional programming techniques are used. However, as has been noted elsewhere, as currently implemented it establishes strong implicit dependencies between components, hampering independent software development and evolution. To address this problem, we present a type-based modularization of implicit invocation with implicit announcement that is inspired by how interfaces and exceptions are realized in JAVA. By extending an existing compiler and by rewriting several programs to make use of our proposed language constructs, we found that the imposed declaration clutter tends to be moderate; in particular, we found that for general applications of implicit invocation with implicit announcement, fears that programs utilizing our form of modularization become unreasonably verbose are unjustified.
  • Sven Apel, Jörg Liebig, Christian Lengauer, Christian Kästner, and William R. Cook. Semistructured Merge in Revision Control Systems. In Proceedings of the Fourth International Workshop on Variability Modelling of Software-intensive Systems (VaMoS), pages 13–20, Essen, January 2010. University of Duisburg-Essen.
    Revision control systems are a major means to manage versions and variants of today's software systems. An ongoing problem in these systems is how to resolve conflicts when merging independently developed revisions. Unstructured revision control systems are purely text-based and solve conflicts based on textual similarity. Structured revision control systems are tailored to specific languages and use language-specific knowledge for conflict resolution. We propose semistructured revision control systems to inherit the strengths of both classes of systems: generality and expressiveness. The idea is to provide structural information of the underlying software artifacts in the form of annotated grammars, which is motivated by recent work on software product lines. This way, a wide variety of languages can be supported and the information provided can assist the resolution of conflicts. We have implemented a preliminary tool and report on our experience with merging Java artifacts. We believe that drawing a connection between revision control systems and product lines has benefits for both fields.
  • Sven Apel, Christian Kästner, Größlinger, and Christian Lengauer. Type Safety for Feature-Oriented Product Lines. Automated Software Engineering – An International Journal, 2010. to appear; submitted August 23, 2009; accepted February 3, 2010.
    A feature-oriented product line is a family of programs that share a common set of features. A feature implements a stakeholder’s requirement and represents a design decision or configuration option. When added to a program, a feature involves the introduction of new structures, such as classes and methods, and the refinement of existing ones, such as extending methods. A feature-oriented decomposition enables a generator to create an executable program by composing feature code solely on the basis of the feature selection of a user – no other information needed. A key challenge of product line engineering is to guarantee that only well-typed programs are generated. As the number of valid feature combinations grows combinatorially with the number of features, it is not feasible to type check all programs individually. The only feasible approach is to have a type system check the entire code base of the feature-oriented product line. We have developed such a type system on the basis of a formal model of a feature-oriented Java-like language. The type system guaranties type safety for feature-oriented product lines. That is, it ensures that every valid program of a well-typed product line is well-typed. Our formal model including type system is sound and complete.
  • Sven Apel, Christian Lengauer, Bernhard Möller, and Christian Kästner. An Algebraic Foundation for Automatic Feature-Based Program Synthesis. Science of Computer Programming (SCP), 2010. to appear; submitted November 25, 2008; accepted February 8, 2010. (PDF)
    Feature-Oriented Software Development (FOSD) provides a multitude of formalisms, methods, languages, and tools for building variable, customizable, and extensible software. Along different lines of research, different notions of a feature have been developed. Although these notions have similar goals, no common basis for evaluation, comparison, and integration exists. We present a feature algebra that captures the key ideas of feature orientation and provides a common ground for current and future research in this field, in which also alternative options can be explored. Furthermore, our algebraic framework is meant to serve as a basis for the upcoming development paradigms automatic feature-based program synthesis and architectural metaprogramming.
  • Janet Feigenspan, Christian Kästner, Mathias Frisch, Raimund Dachselt, and Sven Apel. Visual Support for Understanding Product Lines. In Proceedings of the 18th International Conference on Program Comprehension (ICPC), pages 34–35. IEEE Computer Society, 2010. Tool demo.
    The C preprocessor is often used in practice to implement variability in software product lines. Using #ifdef statements provokes problems such as obfuscated source code, yet they will still be used in practice at least in the medium-term future. With CIDE, we demonstrate a tool to improve understanding and maintaining code that contains #ifdef statements by visualizing them with colors and providing different views on the code.
  • Sandro Schulze, Sven Apel, and Christian Kästner. Code Clones in Feature-Oriented Software Product Lines. In ACM International Conference on Generative Programming and Component Engineering (GPCE). ACM Press, October 2010.
  • M. Kuhlemann, C. Kästner, and S. Apel. Reducing code replication in delegation-based Java programs, volume Java Software and Embedded Systems, chapter 8, pages 171–183. Nova Science Publishers, Inc., 2010.
  • S. Apel, S. Kolesnikov, J. Liebig, C. Kästner, M. Kuhlemann, and T. Leich. Access control in feature-oriented programming. Science of Computer Programming, Volume Special Issue on Feature-Oriented Software Development, 2010.

2009

  • Mario Pukall, Christian Kästner, Sebastian Götz, Walter Cazzola, and Gunter Saake. Flexible Runtime Program Adaptations in Java - A Comparison. Technical Report 14, School of Computer Science, University of Magdeburg, November 2009.
  • Martin Kuhlemann, Don Batory, and Christian Kästner. Safe Composition of Non-Monotonic Features. In Proceedings of the 8th International Conference on Generative Programming and Component Engineering (GPCE), pages 177–186. ACM Press, October 2009.
    Programs can be composed from features. We want to verify automatically that all legal combinations of features can be composed safely without errors. Prior work on this problem assumed that features add code monotonically. We generalize prior work to enable features to both add and remove code, describe our analyses and implementation, and review case studies. We observe that more expressive features can increase the complexity of developed programs rapidly – up to the point where automated concepts as presented in this paper are not a helpful tool but a necessity for verification.
  • Christian Kästner, Sven Apel, and Martin Kuhlemann. A Model of Refactoring Physically and Virtually Separated Features. In Proceedings of the 8th International Conference on Generative Programming and Component Engineering (GPCE), pages 157–166. ACM Press, October 2009.
    Physical separation with class refinements and method refinements à la AHEAD and virtual separation using annotations à la emph #ifdef or CIDE are two competing groups of implementation approaches for software product lines with complementary advantages. Although both groups have been mainly discussed in isolation, we strive for an integration to leverage the respective advantages. In this paper, we provide the basis for such an integration by providing a model that supports both, physical and virtual separation, and by describing refactorings in both directions. We prove the refactorings complete, such that every virtually separated product line can be automatically transformed into a physically separated one (replacing annotations by refinements) and vice versa. To demonstrate the feasibility of our approach, we have implemented the refactorings in our tool CIDE and conducted four case studies.
  • Sven Apel, Jörg Liebig, Christian Kästner, Martin Kuhlemann, and Thomas Leich. An Orthogonal Access Modifier Model for Feature-Oriented Programming. In Proceedings of the First Workshop on Feature-Oriented Software Development (FOSD), pages 27–34. ACM Press, October 2009. (PDF)
    In feature-oriented programming (FOP), a programmer decomposes a program in terms of features. Ideally, features are implemented modularly so that they can be developed in isolation. Access control is an important ingredient to attain feature modularity as it provides mechanisms to hide and expose internal details of a module's implementation. But developers of contemporary feature-oriented languages did not consider access control mechanisms so far. The absence of a well-defined access control model for FOP breaks the encapsulation of feature code and leads to unexpected and undefined program behaviors as well as inadvertent type errors, as we will demonstrate. The reason for these problems is that common object-oriented modifiers, typically provided by the base language, are not expressive enough for FOP and interact in subtle ways with feature-oriented language mechanisms. We raise awareness of this problem, propose three feature-oriented modifiers for access control, and present an orthogonal access modifier model.
  • Janet Feigenspan, Christian Kästner, Sven Apel, and Thomas Leich. How to Compare Program Comprehension in FOSD Empirically – An Experience Report. In Proceedings of the First Workshop on Feature-Oriented Software Development (FOSD), pages 55–62. ACM Press, October 2009.
    There are many different implementation approaches to realize the vision of feature oriented software development, ranging from simple preprocessors, over feature-oriented programming, to sophisticated aspect-oriented mechanisms. Their impact on readability and maintainability (or program comprehension in general) has caused a debate among researchers, but sound empirical results are missing. We report experience from our endeavor to conduct experiments to measure the influence of different implementation mechanisms on program comprehension. We describe how to design such experiments and report from possibilities and pitfalls we encountered. Finally, we present some early results of our first experiment on comparing CPP with CIDE.
  • Sven Apel, William Cook, Krzysztof Czarnecki, Christian Kästner, Neil Loughran, and Oscar Nierstrasz, editors. Proceedings of the First International Workshop on Feature-Oriented Software Development (FOSD), October 6, 2009, Denver, Colorado, USA. ACM Press, October 2009.
  • Christian Kästner and Sven Apel. Virtual Separation of Concerns – A Second Chance for Preprocessors. Journal of Object Technology (JOT), 8(6):59–78, September 2009. Refereed Column.
    Conditional compilation with preprocessors like cpp is a simple but effective means to implement variability. By annotating code fragments with emph #ifdef and emph #endif directives, different program variants with or without these fragments can be created, which can be used (among others) to implement software product lines. Although, preprocessors are frequently used in practice, they are often criticized for their negative effect on code quality and maintainability. In contrast to modularized implementations, for example using components or aspects, preprocessors neglect separation of concerns, are prone to introduce subtle errors, can entirely obfuscate the source code, and limit reuse. Our aim is to rehabilitate the preprocessor by showing how simple tool support can address these problems and emulate some benefits of modularized implementations. At the same time we emphasize unique benefits of preprocessors, like simplicity and language independence. Although we do not have a definitive answer on how to implement variability, we want highlight opportunities to improve preprocessors and encourage research toward novel preprocessor-based approaches.
  • Christian Kästner, Sven Apel, Syed Saif ur Rahman, Marko Rosenmüller, Don Batory, and Gunter Saake. On the Impact of the Optional Feature Problem: Analysis and Case Studies. In Proceedings of the 13th International Software Product Line Conference (SPLC), pages 181–190. SEI, August 2009.
    A software product-line is a family of related programs that are distinguished in terms of features. A feature implements a stakeholders' requirement. Different program variants specified by distinct feature selections are produced from a common code base. The optional feature problem describes a common mismatch between variability intended in the domain and dependencies in the implementation. When this occurs, some variants that are valid in the domain cannot be produced due to implementation issues. There are many different solutions to the optional feature problem, but they all suffer from drawbacks such as reduced variability, increased development effort, reduced efficiency, or reduced source code quality. In this paper, we examine the impact of the optional feature problem in two case studies in the domain of embedded database systems, and we survey different state-of-the-art solutions and their trade-offs. Our intension is to raise awareness of the problem, to guide developers in selecting an appropriate solution for their product-line project, and to identify opportunities for future research.
  • Sven Apel, Christian Kästner, Armin Größlinger, and Christian Lengauer. Feature (De)composition in Functional Programming. In Proceedings of the International Conference on Software Composition (SC), volume 5634 of Lecture Notes in Computer Science, pages 9–26. Springer, July 2009.
    The separation of concerns is a fundamental principle in software engineering. Crosscutting concerns are concerns that do not align with hierarchical and block decomposition supported by mainstream programming languages. In the past, crosscutting concerns have been studied mainly in the context of object orientation. Feature orientation is a novel programming paradigm that supports the (de)composition of crosscutting concerns in a system with a hierarchical block structure. By means of two case studies we explore the problem of crosscutting concerns in functional programming and propose two solutions based on feature orientation.
  • Stefan Boxleitner, Sven Apel, and Christian Kästner. Language-Independent Quantification and Weaving for Feature Composition. In Proceedings of the International Conference on Software Composition (SC), volume 5634 of Lecture Notes in Computer Science, pages 45–54. Springer, July 2009. (PDF)
    Based on a general model of feature composition, we present a composition language that enables programmers by means of quantification and weaving to formulate extensions to programs written in different languages. We explore the design space of composition languages that rely on quantification and weaving and discuss our choices. We outline a tool that extends an existing infrastructure for feature composition and discuss results of three initial case studies.
  • Sven Apel, Florian Janda, Salvador Trujillo, and Christian Kästner. Model Superimposition in Software Product Lines. In Proceedings of the International Conference on Model Transformation (ICMT), volume 5563 of Lecture Notes in Computer Science, pages 4–19. Springer, July 2009. (PDF)
    In software product line engineering, feature composition generates software tailored to specific requirements from a common set of artifacts. Superimposition is a popular technique to merge code pieces belonging to different features. The advent of model-driven development raises the question of how to support the variability of software product lines in modeling techniques. We propose to use superimposition as a model composition technique in order to support variability. We analyze the feasibility of superimposition as a model composition technique, offer a corresponding tool for model composition, and discuss our experiences with three case studies (including one industrial study) using this tool.
  • Sven Apel and Christian Kästner. An Overview of Feature-Oriented Software Development. Journal of Object Technology (JOT), 8(5):49–84, July 2009. Refereed Column.
    Feature-oriented software development (FOSD) is a paradigm for the construction, customization, and synthesis of large-scale software systems. In this survey, we give an overview and a personal perspective on the roots of FOSD, connections to other software development paradigms, and recent developments in this field. Our aim is to point to connections between different lines of research and to identify open issues.
  • Christian Kästner, Sven Apel, Salvador Trujillo, Martin Kuhlemann, and Don Batory. Guaranteeing Syntactic Correctness for all Product Line Variants: A Language-Independent Approach. In Proceedings of the 47th International Conference Objects, Models, Components, Patterns (TOOLS EUROPE), volume 33 of Lecture Notes in Business Information Processing, pages 175–194. Springer, June 2009. (PDF)
    A software product line (SPL) is a family of related program variants in a well-defined domain, generated from a set of features. A fundamental difference from classical application development is that engineers develop not a single program but a whole family with hundreds to millions of variants. This makes it infeasible to separately check every distinct variant for errors. Still engineers want guarantees on the entire SPL. A further challenge is that an SPL may contain artifacts in different languages (code, documentation, models, etc.) that should be checked. In this paper, we present CIDE, an SPL development tool that guarantees syntactic correctness for all variants of an SPL. We show how CIDE's underlying mechanism abstracts from textual representation and we generalize it to arbitrary languages. Furthermore, we automate the generation of safe plug-ins for additional languages from annotated grammars. To demonstrate the language-independent capabilities, we applied CIDE to a series of case studies with artifacts written in Java, C++, C, Haskell, ANTLR, HTML, and XML.
  • Sven Apel, Christian Kästner, Armin Größlinger, and Christian Lengauer. Type-Safe Feature-Oriented Product Lines. Technical Report MIP-0909, Department of Informatics and Mathematics, University of Passau, Germany, June 2009.
  • Sven Apel, Christian Kästner, and Christian Lengauer. FeatureHouse: Language-Independent, Automated Software Composition. In Proceedings of the 31th International Conference on Software Engineering (ICSE), pages 221–231. IEEE Computer Society, May 2009.
    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.
  • Thomas Thüm, Don Batory, and Christian Kästner. Reasoning about Edits to Feature Models. In Proceedings of the 31th International Conference on Software Engineering (ICSE), pages 254–264. IEEE Computer Society, May 2009.
    Features express the variabilities and commonalities among programs in a software product line (SPL). A feature model defines the valid combinations of features, where each combination corresponds to a program in an SPL. SPLs and their feature models evolve over time. We classify the evolution of a feature model via modifications as refactorings, specializations, generalizations, or arbitrary edits. We present an algorithm to reason about feature model edits to help designers determine how the program membership of an SPL has changed. Our algorithm takes two feature models as input (before and after edit versions), where the set of features in both models are not necessarily the same, and it automatically computes the change classification. Our algorithm is able to give examples of added or deleted products and efficiently classifies edits to even large models that have thousands of features.
  • Christian Kästner, Thomas Thüm, Gunter Saake, Janet Feigenspan, Thomas Leich, Fabian Wielgorz, and Sven Apel. FeatureIDE: Tool Framework for Feature-Oriented Software Development. In Proceedings of the 31th International Conference on Software Engineering (ICSE), pages 611–614. IEEE Computer Society, May 2009. Formal Demonstration paper.
    Tools support is crucial for the acceptance of a new programming language. However, providing such tool support is a huge investment that can usually not be provided for a research language. With FeatureIDE, we have built an IDE for AHEAD that integrates all phases of featureoriented software development. To reuse this investment for other tools and languages, we refactored FeatureIDE into an open source framework that encapsulates the common ideas of feature-oriented software development and that can be reused and extended beyond AHEAD. Among others, we implemented extensions for FeatureC++ and FeatureHouse, but in general, FeatureIDE is open for everybody to showcase new research results and make them usable to a wide audience of students, researchers, and practitioners.
  • Christian Kästner, Sven Apel, and Martin Kuhlemann. LJAR: A Model of Refactoring Physically and Virtually Separated Features. Technical Report 08, School of Computer Science, University of Magdeburg, Germany, May 2009.
  • Christian Kästner, Sven Apel, and Gunter Saake. Sichere Produktlinien: Herausforderungen für Syntax- und Typ-Prüfungen. In Bernd Brassel and Michael Hanus, editors, Proceedings des 26. Workshop der GI-Fachgruppe Programmiersprachen und Rechenkonzepte, number 0915, pages 37–38. University of Kiel, May 2009.
  • Norbert Siegmund, Christian Kästner, Marko Rosenmüller, Florian Heidenreich, Sven Apel, and Gunter Saake. Bridging the Gap Between Variability in Client Application and Database Schema. In 13. GI-Fachtagung Datenbanksysteme für Business, Technologie und Web (BTW), pages 297–306. GI, March 2009.
    Database schemas are used to describe the logical design of a database. Diverse groups of users have different perspectives on the schema which leads to different local schemas. Research has focused on view integration to generate a global, consistent schema out of different local schemas or views. However, this approach seems to be too constrained when the generated global view should be variable and only a certain subset is needed. Variable schemas are needed in software product lines in which products are tailored to the needs of stakeholders. We claim that traditional modeling techniques are not sufficient for expressing a variable database schema. We show that software product line methodologies, when applied to the database schemas, overcome existing limitations and allow the generation of tailor-made database schemas.
  • Marko Rosenmüller, Christian Kästner, Norbert Siegmund, Sagar Sunkle, Sven Apel, Thomas Leich, and Gunter Saake. SQL à la Carte – Toward Tailor-made Data Management. In Datenbanksysteme in Business, Technologie und Web (BTW), pages 117–136, March 2009.
    The size of the structured query language (SQL) continuously increases. Extensions of SQL for special domains like stream processing or sensor networks come with own extensions, more or less unrelated to the standard. In general, underlying DBMS support only a subset of SQL plus vendor specific extensions. In this paper, we analyze application domains where special SQL dialects are needed or are already in use. We show how SQL can be decomposed to create an extensible family of SQL dialects. Concrete dialects, e.g., a dialect for web databases, can be generated from such a family by choosing SQL features à la carte. A family of SQL dialects simplifies analysis of the standard when deriving a concrete dialect, makes it easy to understand parts of the standard, and eases extension for new application domains. It is also the starting point for developing tailor-made data management solutions that support only a subset of SQL. We outline how such customizable DBMS can be developed and what benefits, e.g., improved maintainability and performance, we can expect from this.
  • Sven Apel, Christian Kästner, and Christian Lengauer. Vergleich und Integration von Komposition und Annotation zur Implementierung von Produktlinien. In Software Engineering 2009 – Fachtagung des GI-Fachbereichs Softwaretechnik, volume P-143 of Lecture Notes in Informatics, pages 101–112. Gesellschaft für Informatik (GI), March 2009.
    Es gibt eine Vielzahl sehr unterschiedlicher Techniken, Sprachen und Werkzeuge zur Entwicklung von Softwareproduktlinien. Trotzdem liegen gemeinsame Mechanismen zu Grunde, die eine Klassifikation in Kompositions- und Annotationsansatz erlauben. Während der Kompositionsansatz in der Forschung große Beachtung findet, kommt im industriellen Umfeld hauptsächlich der Annotationsansatz zur Anwendung. Wir analysieren und vergleichen beide Ansätze anhand von drei repräsentativen Vertretern und identifizieren anhand von sechs Kriterien individuelle Stärken und Schwächen. Wir stellen fest, dass die jeweiligen Stärken und Schwächen komplementär sind. Aus diesem Grund schlagen wir die Integration des Kompositions- und Annotationsansatzes vor, um so die Vorteile beider zu vereinen, dem Entwickler eine breiteres Spektrum an Implementierungsmechanismen zu Verfügung zu stellen und die Einführung von Produktlinientechnologie in bestehende Softwareprojekte zu erleichtern.
  • Gunter Saake, Marko Rosenmüller, Norbert Siegmund, Christian Kästner, and Thomas Leich. Downsizing Data Management for Embedded Systems. Egyptian Computer Science Journal (ECS), 31(1):1–13, January 2009.
    Data management functionality is not only needed in large scale database management systems, but also in embedded systems that are the predominant form of computing systems today. However, resource restrictions and heterogeneity of hardware complicate the development of data management solutions. In current practice, this typically leads to redevelopment of data management solutions since existing applications cannot be customized sufficiently. In this paper we describe our vision of tailor-made data management, based on a software product line approach, where data management software can be tailored to satisfy special requirements. We illustrate how such a software product line for data management functionality can be derived by downsizing existing database systems.
  • M. Kuhlemann, D. Batory, and C. Kästner. Safe composition of refactoring feature modules. Technical Report 7, Faculty of Computer Science, University of Magdeburg, 2009.

2008

  • Mario Pukall, Christian Kästner, and Gunter Saake. Towards Unanticipated Runtime Adaptation of Java Applications. In Proceedings of the 15th International Asia-Pacific Conference on Software Engineering (APSEC), pages 85–93. IEEE Computer Society, December 2008.
    Modifying an application usually means to stop the application, apply the changes, and start the application again. That means, the application is not available for at least a short time period. This is not acceptable for highly available applications. One reasonable approach which faces the problem of unavailability is to change highly available applications at runtime. To allow extensive runtime adaptation the application must be enabled for unanticipated changes even of already executed program parts. This is due to the fact that it is not predictable what changes become necessary and when they have to be applied. Since Java is commonly used for developing highly available applications, we discuss its shortcomings and opportunities regarding unanticipated runtime adaptation. We present an approach based on Java HotSwap and object wrapping which overcomes the identified shortcomings and evaluate it in a case study.
  • Norbert Siegmund, Marko Rosenmüller, Martin Kuhlemann, Christian Kästner, and Gunter Saake. Measuring Non-functional Properties in Software Product Lines for Product Derivation. In Proceedings of the 15th International Asia-Pacific Software Engineering Conference (APSEC), pages 187–194. IEEE Computer Society, December 2008. Acceptance rate: 30 % (66/221).
    Software product lines (SPLs) enable stakeholders to derive different software products for a domain while providing a high degree of reuse of their code units. Software products are derived in a configuration process by combining different code units. This configuration process becomes complex if SPLs contain hundreds of features. In many cases, a stakeholder is not only interested in functional but also in resulting non-functional properties of a desired product. Because SPLs can be used in different application scenarios alternative implementations of already existing functionality are developed to meet special nonfunctional requirements, like restricted binary size and performance guarantees. To enable these complex configurations we discuss and present techniques to measure nonfunctional properties of software modules and use these values to compute SPL configurations optimized to the users needs.
  • Sven Apel, Christian Kästner, Armin Größlinger, and Christian Lengauer. On Feature Orientation and Functional Programming. Technical Report MIP-0806, Department of Informatics and Mathematics, University of Passau, November 2008.
  • Chang Hwan Peter Kim, Christian Kästner, and Don Batory. On the Modularity of Feature Interactions. In Proceedings of the 7th International Conference on Generative Programming and Component Engineering (GPCE), pages 23–34. ACM Press, October 2008.
    Feature modules are the building blocks of programs in software product lines (SPLs). A foundational assumption of feature-based program synthesis is that features are composed in a predefined order. Recent work on virtual separation of concerns reveals a new model of feature interactions that shows that feature modules can be quantized as compositions of smaller modules called derivatives. We present this model and examine some of its unintuitive consequences, namely, that (1) a given program can be reconstructed by composing features in any order, and (2) the contents of a feature module (as expressed as a composition of derivatives) is determined automatically by a feature order. We show that different orders allow one to `adjust' the contents of a feature module to isolate and study the impact of interactions that a feature has with other features. Using derivatives, we show the utility of generalizing safe composition (SC), a basic analysis of SPLs that verifies program type-safety, to prove that every legal composition of derivatives (and thus any composition order of features) produces a typesafe program, which is a much stronger SC property.
  • Sven Apel, Christian Kästner, and Don Batory. Program Refactoring using Functional Aspects. In Proceedings of the 7th International Conference on Generative Programming and Component Engineering (GPCE), pages 161–170. ACM Press, October 2008.
    A functional aspect is an aspect that has the semantics of a transformation; it is a function that maps a program to an advised program. Functional aspects are composed by function composition. In this paper, we explore functional aspects in the context of aspect-oriented refactoring. We show that refactoring legacy applications using functional aspects is just as flexible as traditional aspects in that (a) the order in which aspects are refactored does not matter, and (b) the number of potential aspect interactions is decreased. We analyze several aspect-oriented programs of different sizes to support our claims.
  • Sven Apel, Christian Kästner, and Christian Lengauer. Feature Featherweight Java: A Calculus for Feature-Oriented Programming and Stepwise Refinement. In Proceedings of the 7th International Conference on Generative Programming and Component Engineering (GPCE), pages 101–112. ACM Press, October 2008.
    Feature-oriented programming (FOP) is a paradigm that incorporates programming language technology, program generation techniques, and stepwise refinement. In their GPCE'07 paper, Thaker et al. suggest the development of a type system for FOP to guarantee safe feature composition, i.e, to guarantee the absence of type errors during feature composition. We present such a type system along with a calculus for a simple feature-oriented, Java-like language, called Feature Featherweight Java (FFJ). Furthermore, we explore four extensions of FFJ and how they affect type soundness.
  • Marko Rosenmüller, Norbert Siegmund, Syed Saif ur Rahman, and Christian Kästner. Modeling Dependent Software Product Lines. In Proceedings of the GPCE Workshop on Modularization, Composition and Generative Techniques for Product Line Engineering (McGPLE), number MIP-0802, pages 13–18. Department of Informatics and Mathematics, University of Passau, October 2008.
  • Christian Kästner and Sven Apel. Integrating Compositional and Annotative Approaches for Product Line Engineering. In Proceedings of the GPCE Workshop on Modularization, Composition and Generative Techniques for Product Line Engineering (McGPLE), number MIP-0802, pages 35–40. Department of Informatics and Mathematics, University of Passau, October 2008.
    Software product lines can be implemented with many different approaches. However, there are common underlying mechanisms which allow a classification into compositional and annotative approaches. While research focuses mainly on composition approaches like aspect- or feature-oriented programming because those support feature traceability and modularity, in practice annotative approaches like preprocessors are common as they are easier to adopt. In this paper, we compare both groups of approaches and find complementary strengths. We propose an integration of compositional and annotative approaches to combine advantages, increase flexibility for the developer, and ease adoption.
  • Christian Kästner and Sven Apel. Type-checking Software Product Lines - A Formal Approach. In Proceedings on the 23rd IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 258–267. IEEE Computer Society, September 2008. (PDF)
    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.
  • Christian Kästner, Salvador Trujillo, and Sven Apel. Visualizing Software Product Line Variabilities in Source Code. In Proceedings of the 2nd International SPLC Workshop on Visualisation in Software Product Line Engineering (ViSPLE), September 2008.
    Implementing software product lines is a challenging task. Depending on the implementation technique the code that realizes a feature is often scattered across multiple code units. This way it becomes difficult to trace features in source code which hinders maintenance and evolution. While previous effort on visualization technologies in software product lines has focused mainly on the feature model, we suggest tool support for feature traceability in the code base. With our tool CIDE, we propose an approach based on filters and views on source code in order to visualize and trace features in source code.
  • Sven Apel, Christian Lengauer, Bernhard Möller, and Christian Kästner. An Algebra for Features and Feature Composition. In Proceedings of the 12th International Conference on Algebraic Methodology and Software Technology (AMAST), volume 5140 of Lecture Notes in Computer Science, pages 36–50. Springer-Verlag, July 2008.
    Feature-Oriented Software Development (FOSD) provides a multitude of formalisms, methods, languages, and tools for building variable, customizable, and extensible software. Along different lines of research, different notions of a feature have been developed. Although these notions have similar goals, no common basis for evaluation, comparison, and integration exists. We present a feature algebra that captures the key ideas of feature orientation and provides a common ground for current and future research in this field, in which also alternative options can be explored.
  • Christian Kästner, Sven Apel, and Martin Kuhlemann. Granularity in Software Product Lines. In Proceedings of the 30th International Conference on Software Engineering (ICSE), pages 311–320, New York, NY, USA, May 2008. ACM. (PDF)
    Building software product lines (SPLs) with features is a challenging task. Many SPL implementations support features with coarse granularity - e.g., the ability to add and wrap entire methods. However, fine-grained extensions, like adding a statement in the middle of a method, either require intricate workarounds or obfuscate the base code with annotations. Though many SPLs can and have been implemented with the coarse granularity of existing approaches, fine-grained extensions are essential when extracting features from legacy applications. Furthermore, also some existing SPLs could benefit from fine-grained extensions to reduce code replication or improve readability. In this paper, we analyze the effects of feature granularity in SPLs and present a tool, called Colored IDE (CIDE), that allows features to implement coarse-grained and fine-grained extensions in a concise way. In two case studies, we show how CIDE simplifies SPL development compared to traditional approaches.
  • Sven Apel, Christian Kaestner, and Christian Lengauer. Research Challenges in the Tension Between Features and Services. In Proc. ICSE Workshop on Systems Development in SOA Environments (SDSOA), pages 53–58, New York, NY, USA, May 2008. ACM.
    We present a feature-based approach, known from software product lines, to the development of service-oriented architectures. We discuss five benefits of such an approach: improvements in modularity, variability, uniformity, specifiability, and typeability. Subsequently, we review preliminary experiences and results, and propose an agenda for further research in this direction.
  • Sven Apel, Christian Kästner, and Christian Lengauer. An Overview of Feature Featherweight Java. Technical Report MIP-0802, Department of Informatics and Mathematics, University of Passau, Germany, April 2008.
  • Christian Kästner, Sven Apel, Salvador Trujillo, Martin Kuhlemann, and Don Batory. Language-Independent Safe Decomposition of Legacy Applications into Features. Technical Report 2, School of Computer Science, University of Magdeburg, Germany, March 2008. (PDF)
  • N. Siegmund, M. Kuhlemann, M. Rosenmüller, C. Kästner, and G. Saake. Integrated Product Line Model for Semi-Automated Product Derivation Using Non-Functional Properties. In International Workshop on Variability Modelling of Software-intensive Systems (VaMoS), pages 25–32, January 2008.
    Software product lines (SPL) allow to generate tailormade software by manually configuring reusable core assets. However, SPLs with hundreds of features and millions of possible products require an appropriate support for semi-automated product derivation. This derivation has to be based on non-functional properties that are related to core assets and domain features. Both elements are part of different models connected via complex mappings. We propose a model that integrates features and core assets in order to allow semi-automated product derivation.

2007

  • S. Apel, C. Kaestner, M. Kuhlemann, and T. Leich. Pointcuts, Advice, Refinements, and Collaborations: Similarities, Differences, and Synergies. Innovations in Systems and Software Engineering (ISSE) – A NASA Journal, 3(3-4), December 2007. (PDF)
    Aspect-oriented programming (AOP) is a novel programming paradigm that aims at modularizing complex software. It embraces several mechanisms including (1) pointcuts and advice as well as (2) refinements and collaborations. Though all these mechanisms deal with crosscutting concerns, i.e., a special class of design and implementation problems that challenge traditional programming paradigms, they do so in different ways. In this article we explore their relationship and their impact on software modularity. This helps researchers and practitioners to understand their differences and guides to use the right mechanism for the right problem
  • M. Kuhlemann and C. Kaestner. Reducing the Complexity of AspectJ Mechanisms for Recurring Extensions. In Second GPCE Workshop on Aspect-Oriented Product Line Engineering (AOPLE), October 2007.
    Aspect-Oriented Programming (AOP) aims at modularizing crosscutting concerns. AspectJ is a popular AOP language extension for Java that includes numerous sophisticated mechanisms for implementing crosscutting concerns modularly in one aspect. The language allows to express complex extensions, but at the same time the complexity of some of those mechanisms hamper the writing of simple and recurring extensions, as they are often needed especially in software product lines. In this paper we propose an AspectJ extension that introduces a simplified syntax for simple and recurring extensions. We show that our syntax proposal improves evolvability and modularity in AspectJ programs by avoiding those mechanisms that may harm evolution and modularity if misused. We show that the syntax is applicable for up to 74% of all pointcut and advice mechanisms by analysing three AspectJ case studies.
  • S. Apel, C. Kästner, T. Leich, and G. Saake. Aspect Refinement - Unifying AOP and Stepwise Refinement. Journal of Object Technology (JOT), 6(9):13–33, October 2007. Special Issue. TOOLS EUROPE 2007.
    Stepwise refinement (SWR) is fundamental to software engineering. As aspectoriented programming (AOP) is gaining momentum in software development, aspects should be considered in the light of SWR. In this paper, we elaborate the notion of aspect refinement that unifies AOP and SWR at the architectural level. To reflect this unification to the programming language level, we present an implementation technique for refining aspects based on mixin composition along with a set of language mechanisms for refining all kinds of structural elements of aspects in a uniform way (methods, pointcuts, advice). To underpin our proposal, we contribute a fully functional compiler on top of AspectJ, present a non-trivial, medium-sized case study, and derive a set of programming guidelines.
  • S. Trujillo, C. Kästner, and S. Apel. Product Lines that supply other Product Lines: A Service-Oriented Approach. In SPLC Workshop: Service-Oriented Architectures and Product Lines - What is the Connection?, pages 69–76, Pittsburgh, PA, September 2007. SEI.
    Software product line is a paradigm to develop a family of software products with the goal of reuse. In this paper, we focus on a scenario in which different products from different product lines are combined together in a third product line to yield more elaborate products, i.e., a product line consumes products from third product line suppliers. The issue is not how different products can be produced separately, but how they can be combined together. We propose a service-oriented architecture where product lines are regarded as services, yielding a service-oriented product line. This paper illustrates the approach with an example for a service-oriented architecture of a web portal product line supplied by portlet product lines.
  • C. Kästner. CIDE: Decomposing Legacy Applications into Features. In Proc. Int'l Software Product Line Conference (SPLC), second volume, pages 149–150, September 2007.
    Taking an extractive approach to decompose a legacy application into features is difficult and laborious with current approaches and tools. We present a prototype of a tooldriven approach that largely hides the complexity of the task.
  • C. Kästner, S. Apel, and D. Batory. A Case Study Implementing Features Using AspectJ. In Proc. Int'l Software Product Line Conference (SPLC), pages 223–232, Los Alamitos, CA, USA, September 2007. IEEE Computer Society.
    Software product lines aim to create highly configurable programs from a set of features. Common belief and recent studies suggest that aspects are well-suited for implementing features. We evaluate the suitability of AspectJ with respect to this task by a case study that refactors the embedded database system Berkeley DB into 38 features. Contrary to our initial expectations, the results were not encouraging. As the number of aspects in a feature grows, there is a noticeable decrease in code readability and maintainability. Most of the unique and powerful features of AspectJ were not needed. We document where AspectJ is unsuitable for implementing features of refactored legacy applications and explain why.
  • S. Apel, C. Lengauer, D. Batory, B. Möller, and C. Kästner. An Algebra for Feature-Oriented Software Development. Technical Report MIP-0706, Department of Informatics and Mathematics, University of Passau, July 2007.
  • C. Kästner, M. Kuhlemann, and D. Batory. Automating Feature-Oriented Refactoring of Legacy Applications. In Proceedings of the 1st ECOOP Workshop on Refactoring Tools (WRT), pages 62–63. TU Berlin, July 2007. also presented as poster at ECOOP.
    Creating a software product line from a legacy application is a difficult task. We propose a tool that helps automating tedious tasks of refactoring legacy applications into features and frees the developer from the burden of performing laborious routine implementations.
  • S. Apel, C. Kästner, and S. Trujillo. On the Necessity of Empirical Studies in the Assessment of Modularization Mechanisms for Crosscutting Concerns. In Proceedings of ICSE Workshop on Assessment of Contemporary Modularization Techniques (ACoM'07), page 161. IEEE Computer Society, May 2007.
    Collaborations are a frequently occurring class of crosscutting concerns. Prior work has argued that collaborations are better implemented using Collaboration Languages (CLs) rather than AspectJ-like Languages (ALs). The main argument is that aspects flatten the objectoriented structure of a collaboration, and introduce more complexity rather than benefits – in other words, CLs and ALs differ with regard to program comprehension. To explore the effects of CL and AL modularization mechanisms on program comprehension, we propose to conduct a series of experiments. We present ideas on how to arrange such experiments that should serve as a starting point and foster a discussion with other researchers.
  • Christian Kästner. Aspect-Oriented Refactoring of Berkeley DB. Master thesis (diplomarbeit), University of Magdeburg, Germany, March 2007.

2006

  • S. Apel, C. Kästner, M. Kuhlemann, and T. Leich. Objektorientierte Grenzen - Modularität von Softwarebausteinen: Aspekte versus Merkmale. iX Magazin für Professionelle Informationstechnik, Number 10, pages 116–122, October 2006.
  • Sven Apel, Christian Kästner, Thomas Leich, and Gunter Saake. Aspect Refinement. Technical Report 10, School of Computer Science, University of Magdeburg, Germany, August 2006.
  • C. Kästner, S. Apel, and G. Saake. Implementing Bounded Aspect Quantification in AspectJ. In Proceedings of ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'06), pages 111–122, July 2006.
    The integration of aspects into the methodology of stepwise software development and evolution is still an open issue. This paper focuses on the global quantification mechanism of nowadays aspect-oriented languages that contradicts basic principles of this methodology. One potential solution to this problem is to bound the potentially global effects of aspects to a set of local development steps. We discuss several alternatives to implement such bounded aspect quantification in AspectJ. Afterwards, we describe a concrete approach that relies on meta-data and pointcut restructuring in order to control the quantification of aspects. Finally, we discuss open issues and further work.

Supervised Theses

Copyright Notice: This material is presented to ensure timely dissemination of scholarly and technical work. Copyright and all rights therein are retained by authors or by other copyright holders. All persons copying this information are expected to adhere to the terms and constraints invoked by each author's copyright. In most cases, these works may not be reposted without the explicit permission of the copyright holder.

Grants & Awards