Direkt zum Inhalt
 
 
emo_fb12_progr.jpg
 
  Startseite  
 

own.bib

@INPROCEEDINGS{K:RAMSE06,
  AUTHOR = {Christian K\"astner and Sven Apel and Gunter Saake},
  TITLE = {Implementing Bounded Aspect Quantification in {AspectJ}},
  BOOKTITLE = {Proc.\ ECOOP Workshop on Reflection, AOP, and Meta-Data for Software Evolution (RAM-SE)},
  YEAR = 2006,
  MONTH = JUL,
  LOCATION = {Nantes, France},
  PUBLISHER = {University of Magdeburg},
  ADDRESS = {Magdeburg, Germany},
  EDITORS = {Walter Cazzola and Shigeru Chiba and Yvonne Coady and Gunter Saake},
  PAGES = {111--122},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/RAM-SE2006.pdf},
  ABSTRACT = {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.}
}

@TECHREPORT{aspectrefinement,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Thomas Leich and Gunter Saake},
  TITLE = {Aspect Refinement},
  NUMBER = 10,
  INSTITUTION = {School of Computer Science, University of Magdeburg},
  MONTH = AUG,
  YEAR = 2006,
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/TechReport_10_2006.pdf},
  HIDEABSTRACT = {Stepwise refinement (SWR) is fundamental to software engineering.
As aspect-oriented programming (AOP) gains momentum in
software development, aspects should be subject to SWR as well. In this
paper, we introduce the notion of aspect refinement that unifies AOP
and SWR. To reflect this unification to programming language level, we
present an implementation technique for refining aspects based on mixin
composition. Specifically, we propose a set of concrete mechanisms for
refining all kinds of structural elements of aspects in a uniform way
(methods, pointcuts, advice). To underpin our proposal, we contribute
a formal syntax and semantics specification as well as a fully functional
compiler on top of AspectJ. We apply our approach to a non-trivial case
study and derive several programming guidelines.},
  CROSSCITE = {superseded by \cite{AKLS:TOOLS07}}
}

@ARTICLE{AKKL:IX06,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Martin Kuhlemann and Thomas Leich},
  TITLE = {{Modularit{\"a}t von Softwarebausteinen: Aspekte versus Merkmale}},
  JOURNAL = {iX Magazin f{\"u}r Professionelle Informationstechnik},
  NUMBER = 10,
  MONTH = OCT,
  YEAR = 2006,
  PAGES = {116--122},
  URL = {http://www.heise.de/kiosk/archiv/ix/06/10/116_Objektorientierte_Grenzen},
  ABSTRACT = {Schon seit einigen Jahren macht die aspektorientierte Programmierung von sich reden. Daneben zieht in j{\"u}ngster Zeit die merkmalsorientierte Programmierung die Aufmerksamkeit auf sich. Beide verfolgen mit der Verbesserung der Modularit{\"a}t von Softwarebausteinen {\"a}hnliche Ziele, realisieren dies aber auf unterschiedliche Art und Weise - jeweils mit Vor- und Nachteilen.}
}

@MASTERSTHESIS{kaestnerThesis,
  AUTHOR = {Christian K\"astner},
  TITLE = {Aspect-Oriented Refactoring of {Berkeley DB}},
  SCHOOL = {University of Magdeburg},
  ADDRESS = {Germany},
  MONTH = MAR,
  YEAR = 2007,
  TYPE = {Diplomarbeit},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/thesis_final.pdf}
}

@INPROCEEDINGS{AKT:ACoM07,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Salvador Trujillo},
  TITLE = {On the Necessity of Empirical Studies in the Assessment of Modularization Mechanisms for Crosscutting Concerns},
  BOOKTITLE = {Proc.\ ICSE Workshop on Assessment of Contemporary Modularization Techniques (ACoM)},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Washington, DC},
  LOCATION = {Minneapolis, MN, USA},
  MONTH = MAY,
  YEAR = 2007,
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/ACoM2007.pdf},
  ABSTRACT = {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.}
}

@ARTICLE{AKLS:TOOLS07,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Thomas Leich and Gunter Saake},
  TITLE = {Aspect Refinement - Unifying {AOP} and Stepwise Refinement},
  JOURNAL = {Journal of Object Technology (JOT)},
  VOLUME = 6,
  NUMBER = 9,
  MONTH = OCT,
  YEAR = 2007,
  PAGES = {13--33},
  NOTE = {Special Issue: TOOLS EUROPE 2007},
  NOCOMMENT = {Acceptance rate: 31\,\% (24/78)},
  PDF = {http://www.jot.fm/issues/issue_2007_10/paper1.pdf},
  ABSTRACT = {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.
},
  URL = {http://www.jot.fm/issues/issue_2007_10/paper1/index.html}
}

@INPROCEEDINGS{KAB:SPLC07,
  AUTHOR = {Christian K\"astner and Sven Apel and Don Batory},
  TITLE = {A Case Study Implementing Features Using {AspectJ}},
  BOOKTITLE = {Proceedings of the 11th International Software Product Line Conference (SPLC)},
  YEAR = 2007,
  MONTH = SEP,
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  ISBN = {0-7695-2888-0},
  PAGES = {223-232},
  LOCATION = {Kyoto, Japan},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/splc07.pdf},
  SELECTED = 1,
  NOTE = {Acceptance rate: 35\,\% (28/80)},
  ABSTRACT = {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.}
}

@INPROCEEDINGS{K:SPLCDemo07,
  AUTHOR = {Christian K\"astner},
  TITLE = {{CIDE}: Decomposing Legacy Applications into Features},
  BOOKTITLE = {Proceedings of the 11th International Software Product Line Conference (SPLC), second volume (Demonstration)},
  LOCATION = {Kyoto, Japan},
  YEAR = 2007,
  PAGES = {149--150},
  ISBN = {978-4-7649-0342-5},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/splc07demo.pdf},
  ABSTRACT = {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.}
}

@INPROCEEDINGS{KKB:WRT07,
  AUTHOR = {Christian K{\"a}stner and Martin Kuhlemann and Don Batory},
  TITLE = {Automating Feature-Oriented Refactoring of Legacy Applications},
  BOOKTITLE = {Proceedings of the ECOOP Workshop on Refactoring Tools (WRT)},
  LOCATION = {Berlin, Germany},
  MONTH = JUL,
  YEAR = 2007,
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/ecooprefactoring.pdf},
  ABSTRACT = {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.},
  PAGES = {62--63},
  PUBLISHER = {TU Berlin},
  ADDRESS = {Berlin},
  ISSN = {1436-9915}
}

@TECHREPORT{ALBMK:Passau07,
  AUTHOR = {Sven Apel and Christian Lengauer and Don Batory and 
Bernhard M{\"o}ller and Christian K{\"a}stner},
  TITLE = {An Algebra for Feature-Oriented Software Development},
  INSTITUTION = {Department of Informatics and Mathematics, University 
of Passau},
  NUMBER = {MIP-0706},
  YEAR = 2007,
  PDF = {http://www.infosun.fim.uni-passau.de/cl/staff/apel/publications/mip-0706.pdf},
  HIDEABSTRACT = {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 ideas of what a feature is have been developed. Although
the existing approaches have similar goals, their representations and formalizations
have not been integrated so far into a common framework.
We present a feature algebra as a foundation of FOSD. The algebra captures
the key ideas and provides a common ground for current and future
research in this field, in which also alternative options can be explored.},
  CROSSCITE = {superseded by \cite{ALMK:AMAST08} and \cite{ALMK:SCP10}}
}

@INPROCEEDINGS{TKA:SOAPL07,
  AUTHOR = {Salvador Trujillo and Christian K{\"a}stner and Sven Apel},
  TITLE = {Product Lines that supply other Product Lines: A Service-Oriented Approach},
  BOOKTITLE = {Proceedings of the SPLC Workshop on  Service-Oriented Architectures and Product Lines (SOAPL)},
  LOCATION = {Kyoto, Japan},
  MONTH = SEP,
  YEAR = 2007,
  ADDRESS = {Pittsburgh, PA, USA},
  PUBLISHER = {SEI},
  PAGES = {69-76},
  ABSTRACT = {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.
}
}

@ARTICLE{AKML:NASA07,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Martin Kuhlemann and Thomas Leich},
  TITLE = {Pointcuts, Advice, Refinements, and Collaborations: Similarities, Differences, and Synergies},
  JOURNAL = {Innovations in Systems and Software Engineering (ISSE) -- A NASA Journal},
  VOLUME = 3,
  NUMBER = {3-4},
  PAGES = {281--289},
  ISSN = {1614-5046},
  PUBLISHER = {Springer},
  YEAR = 2007,
  MONTH = DEC,
  ABSTRACT = {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.},
  URL = {http://www.springerlink.com/content/08m600873g3044t4/},
  PDF = {http://www.infosun.fim.uni-passau.de/cl/staff/apel/publications/ISSE2007.pdf}
}

@INPROCEEDINGS{KK:AOPLE07,
  AUTHOR = {Martin Kuhlemann and Christian K{\"a}stner},
  TITLE = {Reducing the Complexity of {AspectJ} Mechanisms for Recurring Extensions},
  BOOKTITLE = {Proc.\ GPCE Workshop on Aspect-Oriented Product Line Engineering (AOPLE)},
  YEAR = 2007,
  PAGES = {14--19},
  LOCATION = {Salzburg, Austria},
  ABSTRACT = {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.},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/aople07.pdf}
}

@INPROCEEDINGS{SKRKS:VaMoS08,
  TITLE = {Integrated Product Line Model for Semi-Automated Product Derivation Using Non-Functional Properties},
  AUTHOR = {Norbert Siegmund and Martin Kuhlemann and Marko Rosenm{\"u}ller and Christian K{\"a}stner and Gunter Saake},
  BOOKTITLE = {Proceedings of the Second International Workshop on Variability Modelling of Software-intensive Systems (VaMoS)},
  YEAR = 2008,
  MONTH = JAN,
  LOCATION = {Essen, Germany},
  PAGES = {25--23},
  ISSN = {1860-2770},
  PUBLISHER = {University of Duisburg-Essen},
  ADDRESS = {Essen, Germany},
  PDF = {http://www.icb.uni-due.de/fileadmin/ICB/research/research_reports/icb_report_22.pdf},
  ABSTRACT = {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.
}
}

@INPROCEEDINGS{KAK:ICSE08,
  TITLE = {Granularity in Software Product Lines},
  AUTHOR = {Christian K\"{a}stner and Sven Apel and Martin Kuhlemann},
  BOOKTITLE = {Proceedings of the 30th International Conference on Software Engineering (ICSE)},
  YEAR = 2008,
  MONTH = MAY,
  LOCATION = {Leipzig, Germany},
  ISBN = {978-1-60558-079-1},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  PAGES = {311--320},
  DOI = {http://doi.acm.org/10.1145/1368088.1368131},
  ACM = {http://dl.acm.org/authorize?063977},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/icse2008.pdf},
  EREADER = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/icse2008_ereader.pdf},
  SELECTED = 1,
  ABSTRACT = {
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.
},
  NOTE = {Acceptance rate: 15\,\% (56/371)}
}

@INPROCEEDINGS{AKL:SDSOA08,
  TITLE = {Research Challenges in the Tension Between Features and Services},
  AUTHOR = {Sven Apel and Christian Kaestner and Christian Lengauer},
  BOOKTITLE = {Proc.\ ICSE Workshop on Systems Development in SOA Environments (SDSOA)},
  YEAR = 2008,
  MONTH = MAY,
  LOCATION = {Leipzig, Germany},
  ISBN = {978-1-60558-029-6},
  PAGES = {53--58},
  DOI = {http://doi.acm.org/10.1145/1370916.1370930},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY, USA},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/sdsoa2008.pdf},
  ABSTRACT = {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.}
}

@TECHREPORT{KATKB:MD08,
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Salvador Trujillo and Martin Kuhlemann and Don Batory},
  TITLE = {Language-Independent Safe Decomposition of Legacy~Applications into Features},
  YEAR = {2008},
  NUMBER = 2,
  INSTITUTION = {School of Computer Science, University of Magdeburg},
  MONTH = MAR,
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/gcidetech.pdf},
  HIDEABSTRACT = {
Software product lines (SPL) usually consist of code and
non-code artifacts written in different languages. Often
they are created by decomposing legacy applications into
features. To handle different artifacts uniformly (code, documentation,
models, etc.), current SPL technologies either
use an approach that is so general that it works on character
or token level, but can easily introduce subtle errors; or they
provide specialized tools for a low number of languages.
Syntax errors that only occur in certain variants are difficult
to detect, as the exploding number of variants makes a manual
testing unfeasible. In this paper, we present CIDE, an
generic SPL tool that can ensure syntactic correctness for
all variants. We show CIDE's underlying mechanism that
abstracts from textual representation and generalize it from
Java to arbitrary languages. Furthermore, we automate the
generation of safe plug-ins for additional languages from
annotated grammars. To demonstrate CIDE's capabilities,
we applied it to a series of case studies with artifacts from
different languages, including Java, C\#, C, Haskell, ANTLR,
and XML.},
  CROSSCITE = {superseded by \cite{KATKB:TOOLS09}}
}

@TECHREPORT{AKL:Passau08,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Christian Lengauer},
  TITLE = {An Overview of Feature Featherweight Java},
  YEAR = {2008},
  MONTH = APR,
  INSTITUTION = {Department of Informatics and Mathematics, University 
of Passau},
  NUMBER = {MIP-0802},
  ADDRESS = {Germany},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/ffjtech.pdf},
  CROSSCITE = {extended material for \cite{AKL:GPCE08}},
  HIDEABSTRACT = {
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 in order to guarantee
safe 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 several extensions of
FFJ and how they affect type soundness.
}
}

@INPROCEEDINGS{ALMK:AMAST08,
  AUTHOR = {Sven Apel and Christian Lengauer and Bernhard M{\"o}ller and Christian K{\"a}stner},
  TITLE = {An Algebra for Features and Feature Composition},
  BOOKTITLE = {Proceedings of the 12th International Conference on Algebraic Methodology and Software Technology (AMAST)},
  SERIES = {Lecture Notes in Computer Science},
  PUBLISHER = {Springer-Verlag},
  ADDRESS = {Berlin/Heidelberg, Germany},
  MONTH = JUL,
  VOLUME = 5140,
  PAGES = {36--50},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/AMAST08.pdf},
  DOI = {http://dx.doi.org/10.1007/978-3-540-79980-1_4},
  YEAR = 2008,
  ABSTRACT = {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.},
  NOTE = {Acceptance rate: 47\,\% (27/58)},
  CROSSCITE = {extended by \cite{ALMK:SCP10}}
}

@INPROCEEDINGS{KA:ASE08,
  AUTHOR = {Christian K{\"a}stner and Sven Apel},
  TITLE = {Type-checking Software Product Lines - A Formal Approach},
  BOOKTITLE = {Proceedings of the 23rd IEEE/ACM International Conference on Automated Software Engineering (ASE)},
  YEAR = 2008,
  MONTH = SEP,
  SELECTED = 1,
  LOCATION = {L'Aquila, Italy},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  ISSN = {1527-1366},
  ISBN = {978-1-4244-2187-9},
  PAGES = {258--267},
  DOI = {http://dx.doi.org/10.1109/ASE.2008.36},
  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.},
  NOTE = {Acceptance rate: 12\,\% (30/280)},
  CROSSCITE = {extended by \cite{KATS:TOSEM11}},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/ASE08.pdf}
}

@INPROCEEDINGS{KKB:GPCE08,
  AUTHOR = {Chang Hwan Peter Kim and Christian K{\"a}stner and Don Batory},
  TITLE = {On the Modularity of Feature Interactions},
  BOOKTITLE = {Proceedings of the 7th International Conference on Generative Programming and Component Engineering (GPCE)},
  YEAR = 2008,
  MONTH = OCT,
  LOCATION = {Nashville, TN, USA},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  ISBN = {978-1-60558-267-2},
  DOI = {http://doi.acm.org/10.1145/1449913.1449919},
  ACM = {http://dl.acm.org/authorize?036803},
  PAGES = {23--34},
  NOTE = {Acceptance rate: 29\,\% (16/55)},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/GPCE08-Kim.pdf},
  ABSTRACT = {
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.
	}
}

@INPROCEEDINGS{AKB:GPCE08,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Don Batory},
  TITLE = {Program Refactoring using Functional Aspects},
  BOOKTITLE = {Proceedings of the 7th International Conference on Generative Programming and Component Engineering (GPCE)},
  YEAR = 2008,
  MONTH = OCT,
  ISBN = {978-1-60558-267-2},
  PAGES = {161--170},
  DOI = {http://doi.acm.org/10.1145/1449913.1449938},
  ACM = {http://dl.acm.org/authorize?036826},
  LOCATION = {Nashville, TN, USA},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  NOTE = {Acceptance rate: 29\,\% (16/55)},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/GPCE08-FA.pdf},
  ABSTRACT = {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.}
}

@INPROCEEDINGS{AKL:GPCE08,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Christian Lengauer},
  TITLE = {{Feature Featherweight Java}: A Calculus for Feature-Oriented Programming and Stepwise Refinement},
  BOOKTITLE = {Proceedings of the 7th International Conference on Generative Programming and Component Engineering (GPCE)},
  YEAR = 2008,
  MONTH = OCT,
  ISBN = {978-1-60558-267-2},
  PAGES = {101--112},
  LOCATION = {Nashville, TN, USA},
  DOI = {http://doi.acm.org/10.1145/1449913.1449931},
  ACM = {http://dl.acm.org/authorize?036811},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  NOTE = {Acceptance rate: 29\,\% (16/55)},
  CROSSCITE = {extended by \cite{AKGL:JASE10}},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/GPCE08-FFJ.pdf},
  ABSTRACT = {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.}
}

@INPROCEEDINGS{KAT:ViSPLE08,
  AUTHOR = {Christian K{\"a}stner and Salvador Trujillo and Sven Apel},
  TITLE = {Visualizing Software Product Line Variabilities in Source Code},
  BOOKTITLE = {Proceedings of the 2nd International SPLC Workshop on Visualisation in Software Product Line Engineering (ViSPLE)},
  YEAR = 2008,
  MONTH = SEP,
  LOCATION = {Limerick, Ireland},
  ISBN = {978-1-905952-06-9},
  PAGES = {303--313},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/ViSPLE08.pdf},
  ABSTRACT = {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.}
}

@INPROCEEDINGS{PKS:APSEC08,
  AUTHOR = {Mario Pukall and Christian K{\"a}stner and Gunter Saake},
  TITLE = {Towards Unanticipated Runtime Adaptation of {Java} Applications},
  BOOKTITLE = {Proceedings of the 15th Asia-Pacific Software Engineering Conference (APSEC)},
  YEAR = 2008,
  MONTH = DEC,
  ISBN = {978-0-7695-3446-6},
  ISSN = {1530-1362},
  PAGES = {85--92},
  LOCATION = {Beijing, China},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  ABSTRACT = {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.},
  NOTE = {Acceptance rate: 30\,\% (66/221)},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/APSEC08-runtime.pdf}
}

@INPROCEEDINGS{SRKKS:APSEC08,
  AUTHOR = {Norbert Siegmund and Marko Rosenm{\"u}ller and Martin Kuhlemann and Christian K{\"a}stner and Gunter Saake},
  TITLE = {Measuring Non-functional Properties in Software Product Lines for Product Derivation},
  BOOKTITLE = {Proceedings of the 15th Asia-Pacific Software Engineering Conference (APSEC)},
  YEAR = 2008,
  MONTH = DEC,
  LOCATION = {Beijing, China},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  ISBN = {978-0-7695-3446-6},
  ISSN = {1530-1362},
  PAGES = {187--194},
  ABSTRACT = {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.},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/APSEC08-nfp.pdf},
  NOTE = {Acceptance rate: 30\,\% (66/221)}
}

@INPROCEEDINGS{RSRK:McGPLE08,
  AUTHOR = {Marko Rosenm{\"u}ller and Norbert Siegmund and Syed Saif ur Rahman and Christian K{\"a}stner},
  TITLE = {Modeling Dependent Software Product Lines},
  BOOKTITLE = {Proceedings of the GPCE Workshop on Modularization, Composition and Generative Techniques for Product Line Engineering (McGPLE)},
  YEAR = 2008,
  MONTH = OCT,
  LOCATION = {Nashville, TN, USA},
  ABSTRACT = {Software product line development is a mature technique to implement
similar programs tailored to serve the needs of multiple
users while providing a high degree of reuse. This approach also
scales for larger product lines that use smaller product lines to fulfill
special tasks. In such compositions of SPLs, the interacting product
lines depend on each other and programs generated from these
product lines have to be correctly configured to ensure correct communication
between them. Constraints between product lines can
be used to allow only valid combinations of generated programs.
This, however, is not sufficient if multiple instances of one product
line are involved. In this paper we present an approach that uses
UML and OO concepts to model compositions of SPLs. The model
extends the approach of constraints between SPLs to constraints between
instances of SPLs and integrates SPL specialization. Based
on this model we apply a feature-oriented approach to simplify the
configuration of complete SPL compositions.},
  PUBLISHER = {University of Passau},
  ADDRESS = {Passau, Germany},
  PAGES = {13--18},
  NONUMBER = {MIP-0802},
  PDF = {http://www.infosun.fim.uni-passau.de/cl/staff/apel/McGPLE2008/papers/McGPLE2008Proceedings.pdf}
}

@INPROCEEDINGS{KA:McGPLE08,
  AUTHOR = {Christian K{\"a}stner and Sven Apel},
  TITLE = {Integrating Compositional and Annotative Approaches for Product Line Engineering},
  BOOKTITLE = {Proceedings of the GPCE Workshop on Modularization, Composition and Generative Techniques for Product Line Engineering (McGPLE)},
  YEAR = 2008,
  MONTH = OCT,
  LOCATION = {Nashville, TN, USA},
  ABSTRACT = {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.},
  PUBLISHER = {University of Passau},
  ADDRESS = {Passau, Germany},
  PAGES = {35--40},
  NONUMBER = {MIP-0802},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/McGPLE08.pdf}
}

@INPROCEEDINGS{AKL:ICSE09,
  TITLE = {{FeatureHouse}: Language-Independent, Automated Software Composition},
  AUTHOR = {Sven Apel and Christian K\"{a}stner and Christian Lengauer},
  BOOKTITLE = {Proceedings of the 31th International Conference on Software Engineering (ICSE)},
  YEAR = 2009,
  MONTH = MAY,
  LOCATION = {Vancouver, Canada},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  SELECTED = 1,
  ISBN = {978-1-4244-3452-7},
  ISSN = {0270-5257},
  PAGES = {221--231},
  ABSTRACT = {
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.},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/icse2009_fh.pdf},
  NOTE = {Acceptance rate: 12\,\% (50/405)}
}

@INPROCEEDINGS{TBK:ICSE09,
  TITLE = {Reasoning about Edits to Feature Models},
  AUTHOR = {Thomas Th{\"u}m and Don Batory and Christian K\"{a}stner},
  BOOKTITLE = {Proceedings of the 31th International Conference on Software Engineering (ICSE)},
  YEAR = 2009,
  MONTH = MAY,
  LOCATION = {Vancouver, Canada},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  SELECTED = 1,
  ISBN = {978-1-4244-3452-7},
  ISSN = {0270-5257},
  PAGES = {254--264},
  ABSTRACT = {
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.},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/icse2009_fm.pdf},
  NOTE = {Acceptance rate: 12\,\% (50/405)}
}

@TECHREPORT{AKGL:Passau08,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Armin Gr{\"o}{\ss}linger and Christian Lengauer},
  TITLE = {On Feature Orientation and Functional Programming},
  INSTITUTION = {Department of Informatics and Mathematics, University 
of Passau},
  NUMBER = {MIP-0806},
  YEAR = 2008,
  MONTH = NOV,
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/mip-0806.pdf},
  HIDEABSTRACT = {
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 implementation of crosscutting concerns in a system with a hierarchical
block structure. We explore the problem of crosscutting concerns in functional
programming and propose two solutions based on feature orientation. Two case
studies support our claims.},
  CROSSCITE = {superseded by \cite{AKGL:SC09}}
}

@INPROCEEDINGS{AKL:SE09,
  TITLE = {{Vergleich und Integration von Komposition und Annotation zur Implementierung von Produktlinien}},
  AUTHOR = {Sven Apel and  Christian K{\"a}stner and Christian Lengauer},
  BOOKTITLE = {Software Engineering 2009 -- Fachtagung des GI-Fachbereichs Softwaretechnik},
  YEAR = 2009,
  MONTH = MAR,
  ABSTRACT = {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{\"a}hrend der Kompositionsansatz in der Forschung gro�e Beachtung findet,
kommt im industriellen Umfeld haupts{\"a}chlich der Annotationsansatz zur Anwendung.
Wir analysieren und vergleichen beide Ans{\"a}tze anhand von drei repr{\"a}sentativen Vertretern
und identifizieren anhand von sechs Kriterien individuelle St{\"a}rken und Schw{\"a}chen.
Wir stellen fest, dass die jeweiligen St{\"a}rken und Schw{\"a}chen komplement{\"a}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{\"u}gung zu stellen und die Einf{\"u}hrung von
Produktlinientechnologie in bestehende Softwareprojekte zu erleichtern.},
  SERIES = {Lecture Notes in Informatics},
  PUBLISHER = {Gesellschaft f{\"u}r Informatik (GI)},
  ADDRESS = {Bonn, Germany},
  VOLUME = {P-143},
  LOCATION = {Kaiserslautern, Germany},
  PAGES = {101--112},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/SE2009.pdf},
  URL = {http://www.gi-ev.de/service/publikationen/lni/gi-edition-proceedings-2009/gi-edition-lecture-notes-in-informatics-lni-p-143.html}
}

@INPROCEEDINGS{SKRHAS:BTW09,
  TITLE = {Bridging the Gap between Variability in Client Application and Database Schema},
  AUTHOR = {Norbert Siegmund and Christian K{\"a}stner and Marko Rosenm{\"u}ller and Florian Heidenreich and Sven Apel and Gunter Saake},
  BOOKTITLE = {Proceedings 13. GI-Fachtagung Datenbanksysteme f{\"u}r Business, Technologie und Web (BTW)},
  YEAR = 2009,
  MONTH = MAR,
  PAGES = {297--306},
  SERIES = {Lecture Notes in Informatics},
  VOLUME = {P-144},
  ISBN = {978-3-88579-238-3},
  ISSN = {1617-5468},
  PUBLISHER = {Gesellschaft f{\"u}r Informatik (GI)},
  ADDRESS = {Bonn, Germany},
  LOCATION = {M{\"u}nster, Germany},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~rosenmue/publications/SKRH08dbschema.pdf},
  ABSTRACT = {
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.
	},
  URL = {http://www.gi-ev.de/service/publikationen/lni/gi-edition-proceedings-2009/gi-edition-lecture-notes-in-informatics-lni-p-144.html}
}

@INPROCEEDINGS{RKSSATS:BTW09,
  TITLE = {SQL \`{a} la Carte -- Toward Tailor-made Data Management},
  AUTHOR = {Marko Rosenm{\"u}ller and Christian K{\"a}stner and Norbert Siegmund and Sagar Sunkle and Sven Apel and Thomas Leich and Gunter Saake},
  BOOKTITLE = {Proceedings 13. GI-Fachtagung Datenbanksysteme f{\"u}r Business, Technologie und Web (BTW)},
  YEAR = 2009,
  MONTH = MAR,
  SERIES = {Lecture Notes in Informatics},
  VOLUME = {P-144},
  ISBN = {978-3-88579-238-3},
  ISSN = {1617-5468},
  PAGES = {117--136},
  PUBLISHER = {Gesellschaft f{\"u}r Informatik (GI)},
  ADDRESS = {Bonn, Germany},
  LOCATION = {M{\"u}nster, Germany},
  ABSTRACT = {
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  \`{a} 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.},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~rosenmue/publications/RKSS08sql.pdf},
  URL = {http://www.gi-ev.de/service/publikationen/lni/gi-edition-proceedings-2009/gi-edition-lecture-notes-in-informatics-lni-p-144.html}
}

@INPROCEEDINGS{KTSFLWA:ICSE09,
  TITLE = {{FeatureIDE}: Tool Framework for Feature-Oriented Software Development},
  AUTHOR = {Christian K\"{a}stner and Thomas Th{\"u}m and Gunter Saake and Janet Feigenspan and Thomas Leich and Fabian Wielgorz and Sven Apel},
  BOOKTITLE = {Proceedings of the 31th International Conference on Software Engineering (ICSE)},
  NOTE = {Formal Demonstration paper, Acceptance rate: 33\,\% (24/72)},
  YEAR = 2009,
  MONTH = MAY,
  LOCATION = {Vancouver, Canada},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  ISBN = {978-1-4244-3452-7},
  ISSN = {0270-5257},
  PAGES = {611--614},
  ABSTRACT = {
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.},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/icse2009_featureide_demo.pdf}
}

@INPROCEEDINGS{KATKB:TOOLS09,
  TITLE = {Guaranteeing Syntactic Correctness for all Product Line Variants: A Language-Independent Approach},
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Salvador Trujillo and Martin Kuhlemann and Don Batory},
  BOOKTITLE = {Proceedings of the 47th International Conference Objects, Models, Components, Patterns (TOOLS EUROPE)},
  YEAR = 2009,
  ISSN = {1865-1348},
  ISBN = {978-3-642-02570-9},
  SERIES = {Lecture Notes in Business Information Processing},
  VOLUME = 33,
  MONTH = JUN,
  SELECTED = 1,
  LOCATION = {Zurich, Switzerland},
  ABSTRACT = {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.},
  DOI = {10.1007/978-3-642-02571-6},
  PUBLISHER = {Springer-Verlag},
  ADDRESS = {Berlin/Heidelberg},
  PAGES = {175--194},
  NOTE = {Acceptance rate: 28\,\% (19 / 67)},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/tools09.pdf},
  URL = {http://www.springerlink.com/content/t8752407443k83j2}
}

@INPROCEEDINGS{BAK:SC09,
  AUTHOR = {Stefan Boxleitner and Sven Apel and Christian K{\"a}stner},
  TITLE = {Language-Independent Quantification and Weaving for Feature Composition},
  BOOKTITLE = {Proceedings of the 8th International Conference on Software Composition (SC)},
  SERIES = {Lecture Notes in Computer Science},
  VOLUME = 5634,
  PAGES = {45--54},
  PUBLISHER = {Springer-Verlag},
  ADDRESS = {Berlin/Heidelberg},
  LOCATION = {Zurich, Switzerland},
  ISSN = {0302-9743},
  ISBN = {978-3-642-02654-6},
  DOI = {10.1007/978-3-642-02655-3_5},
  URL = {http://www.springerlink.com/content/p2p728q15r347576/},
  MONTH = JUL,
  YEAR = 2009,
  ABSTRACT = {
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.
	},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/sc09_mod.pdf},
  NOTE = {Short Paper; Acceptance rate: 33\,\% (10 / 30)}
}

@INPROCEEDINGS{AKGL:SC09,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Armin Gr{\"o}{\ss}linger and Christian Lengauer},
  TITLE = {Feature (De)composition in Functional Programming},
  BOOKTITLE = {Proceedings of the 8th International Conference on Software Composition (SC)},
  SERIES = {Lecture Notes in Computer Science},
  VOLUME = 5634,
  PAGES = {9--26},
  PUBLISHER = {Springer-Verlag},
  ADDRESS = {Berlin/Heidelberg},
  LOCATION = {Zurich, Switzerland},
  ISSN = {0302-9743},
  ISBN = {978-3-642-02654-6},
  DOI = {10.1007/978-3-642-02655-3_3},
  URL = {http://www.springerlink.com/content/m0q4530571t18042/},
  MONTH = JUL,
  YEAR = 2009,
  ABSTRACT = {
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.
		},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/sc09_fc.pdf},
  NOTE = {Acceptance rate: 33\,\% (10 / 30)}
}

@INPROCEEDINGS{AJTK:ICMT09,
  AUTHOR = {Sven Apel and Florian Janda and Salvador Trujillo and Christian K{\"a}stner},
  TITLE = {Model Superimposition in Software Product Lines},
  BOOKTITLE = {Proceedings of the Second International Conference on Model Transformation (ICMT)},
  SERIES = {Lecture Notes in Computer Science},
  VOLUME = 5563,
  PAGES = {4--19},
  PUBLISHER = {Springer-Verlag},
  ADDRESS = {Berlin/Heidelberg},
  LOCATION = {Zurich, Switzerland},
  ISSN = {0302-9743},
  ISBN = {978-3-642-02407-8},
  DOI = {10.1007/978-3-642-02408-5_2},
  URL = {http://www.springerlink.com/content/2k512285p2lv6j04/},
  MONTH = JUN,
  YEAR = 2009,
  ABSTRACT = {
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.
		},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/icmt09.pdf},
  NOTE = {Acceptance rate: 21\,\% (14 / 67)}
}

@ARTICLE{SPAK:TOSEM09,
  AUTHOR = {Friedrich Steimann and Thomas Pawlitzki and Sven Apel and Christian K{\"a}stner},
  TITLE = {Types and Modularity for Implicit Invocation with Implicit Announcement},
  JOURNAL = {ACM Transactions on Software Engineering and Methodology (TOSEM)},
  ACM = {http://dl.acm.org/authorize?387243},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/TOSEM2009.pdf},
  ABSTRACT = {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.},
  YEAR = 2010,
  NUMBER = 1,
  VOLUME = 20,
  PAGES = {Article 1; 43 pages},
  DOI = {http://doi.acm.org/10.1145/1767751.1767752}
}

@INPROCEEDINGS{KAS:GI09,
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Gunter Saake},
  TITLE = {{Sichere Produktlinien: Herausforderungen f{\"u}r Syntax- und Typ-Pr{\"u}fungen}},
  BOOKTITLE = {Proceedings des 26. Workshop der GI-Fachgruppe Programmiersprachen und Rechenkonzepte},
  EDITOR = {Bernd Brassel and Michael Hanus},
  PAGES = {37--38},
  LOCATION = {Bad Honnef},
  YEAR = 2009,
  MONTH = MAY,
  PUBLISHER = {University of Kiel},
  ADDRESS = {Kiel, Germany},
  NUMBER = {0915},
  URL = {http://www.informatik.uni-kiel.de/ifi/forschung/technische-berichte/bericht/?tx_publication_pi1%5Bsingle%5D=162}
}

@INPROCEEDINGS{KARRBS:SPLC09,
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Syed Saif ur Rahman and Marko Rosenm{\"u}ller and Don Batory and Gunter Saake},
  TITLE = {On the Impact of the Optional Feature Problem: Analysis and Case Studies},
  BOOKTITLE = {Proceedings of the 13th International Software Product Line Conference (SPLC)},
  YEAR = 2009,
  MONTH = AUG,
  PUBLISHER = {SEI},
  ADDRESS = {Pittsburgh, PA, USA},
  ISBN = {978-0-9786956-2-0},
  PAGES = {181--190},
  LOCATION = {San Francisco, CA, USA},
  SELECTED = 1,
  ABSTRACT = {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.},
  NOTE = {Acceptance rate: 36\,\% (30 / 83)},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/splc09.pdf}
}

@TECHREPORT{KAK:MD09,
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Martin Kuhlemann},
  TITLE = {{LJ}$^{AR}$: A Model of Refactoring Physically and Virtually Separated Features},
  YEAR = {2009},
  NUMBER = {08},
  INSTITUTION = {School of Computer Science, University of Magdeburg},
  MONTH = MAY,
  PDF = {http://wwwiti.cs.uni-magdeburg.de/iti_db/forschung/cide/LJARTech/ljartech.pdf},
  HIDEABSTRACT = {
Physical separation with class refinements and method refinements � la AHEAD
and virtual separation using annotations � la \#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.},
  CROSSCITE = {extended material for \cite{KAK:GPCE09}}
}

@TECHREPORT{AKGL:Passau09,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Armin Gr{\"o}{\ss}linger and Christian Lengauer},
  TITLE = {Type-Safe Feature-Oriented Product Lines},
  NUMBER = {MIP-0909},
  INSTITUTION = {Department of Informatics and Mathematics, University of Passau},
  MONTH = JUN,
  YEAR = 2009,
  ADDRESS = {Germany},
  PDF = {http://www.infosun.fim.uni-passau.de/cl/publications/docs/MIP-0909.pdf},
  HIDEABSTRACT = {
A feature-oriented product line is a family of programs that share a
common set of features. A feature implements a stakeholder's requirement, represents
a design decision and configuration option and, when added to a program,
involves the introduction of new structures, such as classes and methods, and the
refinement of existing ones, such as extending methods. With feature-oriented
decomposition, programs can be generated, solely on the basis of a user's selection
of features, by the composition of the corresponding feature code. A key
challenge of feature-oriented product line engineering is how to guarantee the
correctness of an entire feature-oriented product line, i.e., of all of the member
programs generated from different combinations of features. As the number of
valid feature combinations grows progressively with the number of features, it
is not feasible to check all individual programs. 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. We demonstrate that the type system ensures
that every valid program of a feature-oriented product line is well-typed and that
the type system is complete.
},
  CROSSCITE = {superseded by \cite{AKGL:JASE10}}
}

@ARTICLE{AK:JOT09,
  AUTHOR = {Sven Apel and Christian K{\"a}stner},
  TITLE = {An Overview of Feature-Oriented Software Development},
  JOURNAL = {Journal of Object Technology (JOT)},
  VOLUME = 8,
  NUMBER = 5,
  PAGES = {49--84},
  MONTH = {July/August},
  YEAR = 2009,
  NOTE = {Refereed Column},
  SELECTED = 1,
  ABSTRACT = {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.},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/JOT09_OverviewFOSD.pdf},
  URL = {http://www.jot.fm/issues/issue_2009_07/column5/index.html}
}

@INPROCEEDINGS{KBK:GPCE09,
  AUTHOR = {Martin Kuhlemann and Don Batory and Christian K{\"a}stner},
  TITLE = {Safe Composition of Non-Monotonic Features},
  BOOKTITLE = {Proceedings of the 8th International Conference on Generative Programming and Component Engineering (GPCE)},
  YEAR = 2009,
  MONTH = OCT,
  LOCATION = {Denver, CO, USA},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  ACM = {http://dl.acm.org/authorize?131383},
  NOTE = {Acceptance rate: 31\,\% (19/62)},
  ISBN = {978-1-60558-828-5},
  PAGES = {177--185},
  DOI = {http://doi.acm.org/10.1145/1621607.1621634},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~mkuhlema/publications/GPCE09.pdf},
  ABSTRACT = {
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.
	}
}

@INPROCEEDINGS{KAK:GPCE09,
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Martin Kuhlemann},
  TITLE = {A Model of Refactoring Physically and Virtually Separated Features},
  BOOKTITLE = {Proceedings of the 8th International Conference on Generative Programming and Component Engineering (GPCE)},
  YEAR = 2009,
  MONTH = OCT,
  LOCATION = {Denver, CO, USA},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  SELECTED = 1,
  NOTE = {Acceptance rate: 31\,\% (19/62)},
  ISBN = {978-1-60558-828-5},
  PAGES = {157--166},
  DOI = {http://doi.acm.org/10.1145/1621607.1621632},
  ACM = {http://dl.acm.org/authorize?131381},
  ABSTRACT = {
Physical separation with class refinements and method refinements \`{a} la AHEAD and virtual separation using annotations \`{a} 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.
	},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/GPCE09-LJAR.pdf}
}

@ARTICLE{KA:JOT09,
  AUTHOR = {Christian K{\"a}stner and Sven Apel},
  TITLE = {Virtual Separation of Concerns -- A Second Chance for Preprocessors},
  JOURNAL = {Journal of Object Technology (JOT)},
  VOLUME = 8,
  NUMBER = 6,
  MONTH = SEP,
  YEAR = 2009,
  PAGES = {59--78},
  SELECTED = 1,
  ABSTRACT = {
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.},
  PDF = {http://www.jot.fm/issues/issue_2009_09/column5.pdf},
  HTTP = {http://www.jot.fm/issues/issue_2009_09/column5/},
  NOTE = {Refereed Column}
}

@INPROCEEDINGS{ALKKL:FOSD09,
  AUTHOR = {Sven Apel and J{\"o}rg Liebig and Christian K{\"a}stner and Martin Kuhlemann and Thomas Leich},
  TITLE = {An Orthogonal Access Modifier Model for Feature-Oriented Programming},
  BOOKTITLE = {Proceedings of the First Workshop on Feature-Oriented Software Development {(FOSD)}},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  LOCATION = {Denver, CO, USA},
  ISBN = {978-1-60558-567-3},
  MONTH = OCT,
  YEAR = 2009,
  ABSTRACT = {
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.
	},
  PDF = {http://www.infosun.fim.uni-passau.de/cl/publications/docs/FOSD2009am.pdf},
  DOI = {http://doi.acm.org/10.1145/1629716.1629723},
  PAGES = {27--34}
}

@INPROCEEDINGS{FKAL:FOSD09,
  AUTHOR = {Janet Feigenspan and Christian K{\"a}stner and Sven Apel and Thomas Leich},
  TITLE = {How to Compare Program Comprehension in FOSD Empirically -- An Experience Report},
  BOOKTITLE = {Proceedings of the First Workshop on Feature-Oriented Software Development (FOSD)},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  LOCATION = {Denver, CO, USA},
  ISBN = {978-1-60558-567-3},
  MONTH = OCT,
  YEAR = 2009,
  DOI = {http://doi.acm.org/10.1145/1629716.1629728},
  ABSTRACT = {
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.
	},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/FOSD09_emp.pdf},
  PAGES = {55--62}
}

@PROCEEDINGS{ACCKLN:FOSD09,
  EDITOR = {Sven Apel and William Cook and Krzysztof Czarnecki and Christian K{\"a}stner and Neil Loughran and Oscar Nierstrasz},
  TITLE = {Proceedings of the First International Workshop on Feature-Oriented Software Development {(FOSD)}, October 6, 2009, Denver, Colorado, USA},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  LOCATION = {Denver, CO, USA},
  ISBN = {978-1-60558-567-3},
  MONTH = OCT,
  YEAR = 2009,
  PDF = {http://www.infosun.fim.uni-passau.de/cl/staff/apel/FOSD2009/FOSD2009_Printed_Proceedings.pdf},
  HTTP = {http://portal.acm.org/citation.cfm?id=1629716}
}

@TECHREPORT{PKGCS:MD09,
  AUTHOR = {Mario Pukall and Christian K{\"a}stner and Sebastian G{\"o}tz and Walter Cazzola and Gunter Saake},
  TITLE = {Flexible Runtime Program Adaptations in {Java} - A Comparison},
  INSTITUTION = {School of Computer Science, University of Magdeburg},
  YEAR = {2009},
  NUMBER = {14},
  MONTH = NOV,
  PDF = {http://www.cs.uni-magdeburg.de/fin_media/downloads/forschung/preprints/2009/TechReport14-p-1591.pdf}
}

@INCOLLECTION{KKA10,
  AUTHOR = {Martin Kuhlemann and Christian K{\"a}stner and Sven Apel},
  TITLE = {Reducing Code Replication in Delegation-Based {Java} Programs},
  BOOKTITLE = {Java Software and Embedded Systems},
  ISBN = {978-1-60741-661-6},
  YEAR = {2010},
  PAGES = {171-183},
  PUBLISHER = {Nova Science Publishers, Inc.},
  ADDRESS = {Hauppauge, NY},
  EDITOR = {Mattis Hayes and Isaiah Johansen},
  URL = {https://www.novapublishers.com/catalog/product_info.php?products_id=10125}
}

@INPROCEEDINGS{KAS:SE10,
  TITLE = {{Virtuelle Trennung von Belangen (Pr{\"a}prozessor 2.0)}},
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Gunter Saake},
  BOOKTITLE = {Software Engineering 2010 -- Fachtagung des GI-Fachbereichs Softwaretechnik},
  YEAR = 2010,
  MONTH = FEB,
  ABSTRACT = {
Bedingte Kompilierung mit Pr{\"a}prozessoren wie \emph{cpp} ist ein einfaches, aber wirksames Mittel zur Implementierung von Variabilit{\"a}t in Softwareproduktlinien. 
  Durch das Annotieren von Code-Fragmenten mit \emph{\#ifdef} und \emph{\#endif} k{\"o}nnen verschiedene Programmvarianten mit oder ohne diesen Fragmenten generiert werden. Obwohl Pr{\"a}prozessoren h{\"a}ufig in der Praxis verwendet werden, werden sie oft f{\"u}r ihre negativen Auswirkungen auf  Codequalit{\"a}t und Wartbarkeit kritisiert. Im Gegensatz zu modularen Implementierungen, etwa mit Komponenten oder Aspekte, vernachl{\"a}ssigen Pr{\"a}prozessoren die Trennung von Belangen im Quelltext, sind anf{\"a}llig f{\"u}r subtile Fehler und verschlechtern die Lesbarkeit des Quellcodes. 
  Wir zeigen, wie einfache Werkzeugunterst{\"u}tzung diese Probleme adressieren und zum Teil beheben bzw.\ die Vorteile einer modularen Implementierung emulieren kann. Gleichzeitig zeigen wir Vorteile von Pr{\"a}prozessoren wie Einfachheit und Sprachunabh{\"a}ngigkeit auf. 	
	},
  SERIES = {Lecture Notes in Informatics},
  NUMBER = {P-159},
  PUBLISHER = {Gesellschaft f{\"u}r Informatik (GI)},
  ADDRESS = {Bonn, Germany},
  LOCATION = {Paderborn, Germany},
  PAGES = {165--176},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/SE2010.pdf},
  NOTE = {Acceptance rate: 36\,\% (17/47)}
}

@INPROCEEDINGS{ALLKC:VaMoS10,
  AUTHOR = {Sven Apel and J{\"o}rg Liebig and Christian Lengauer and Christian K{\"a}stner and William R. Cook},
  TITLE = {Semistructured Merge in Revision Control Systems},
  BOOKTITLE = {Proceedings of the Fourth International Workshop on Variability Modelling of Software-intensive Systems (VaMoS)},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/~ckaestne/VaMoS2010.pdf},
  PUBLISHER = {University of Duisburg-Essen},
  ADDRESS = {Essen, Germany},
  MONTH = JAN,
  YEAR = 2010,
  PAGES = {13--20},
  ABSTRACT = {
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.
	}
}

@INPROCEEDINGS{LALKS:ICSE10,
  TITLE = {An Analysis of the Variability in Forty Preprocessor-Based Software Product Lines},
  AUTHOR = {J{\"o}rg Liebig and Sven Apel and Christian Lengauer and Christian K\"{a}stner and Michael Schulze},
  BOOKTITLE = {Proceedings of the 32nd International Conference on Software Engineering (ICSE)},
  YEAR = 2010,
  MONTH = MAY,
  LOCATION = {Cape Town, South Africa},
  SELECTED = 1,
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  ABSTRACT = {
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 \emph{how} 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.
},
  PAGES = {105--114},
  NOTE = {Acceptance rate: 14\,\% (52/380)},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/iti_db/publikationen/ps/auto/LALKS:ICSE10.pdf},
  ACM = {http://dl.acm.org/authorize?369011},
  DOI = {http://doi.acm.org/10.1145/1806799.1806819}
}

@ARTICLE{AKGL:JASE10,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Armin Gr{\"o}{\ss}linger and Christian Lengauer},
  TITLE = {Type Safety for Feature-Oriented Product Lines},
  JOURNAL = {Automated Software Engineering -- An International Journal},
  YEAR = {2010},
  ISSN = {0928-8910},
  PUBLISHER = {Springer-Verlag},
  SELECTED = 1,
  VOLUME = 17,
  NUMBER = 3,
  PAGES = {251--300},
  URL = {http://www.springerlink.com/content/fh1725331424x665/},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/iti_db/publikationen/ps/auto/AKGL:JASE10.pdf},
  DOI = {http://www.springerlink.com/openurl.asp?genre=article&id;=doi:10.1007/s10515-010-0066-8},
  ABSTRACT = {
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.	
	},
  CROSSCITE = {extended version of \cite{AKL:GPCE08}}
}

@ARTICLE{ALMK:SCP10,
  AUTHOR = {Sven Apel and Christian Lengauer and Bernhard M{\"o}ller and Christian K{\"a}stner},
  TITLE = {An Algebraic Foundation for Automatic Feature-Based Program Synthesis},
  JOURNAL = {Science of Computer Programming (SCP)},
  YEAR = 2010,
  SELECTED = 1,
  DOI = {http://dx.doi.org/10.1016/j.scico.2010.02.001},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/iti_db/publikationen/ps/auto/ALMK:SCP10.pdf},
  VOLUME = 75,
  NUMBER = 11,
  PAGES = {1022-1047},
  MONTH = NOV,
  ABSTRACT = {
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.},
  ISSN = {0167-6423},
  PUBLISHER = {Elsevier},
  CROSSCITE = {extended version of \cite{ALMK:AMAST08}}
}

@INPROCEEDINGS{FKFDA:ICPC2010,
  AUTHOR = {Janet Feigenspan and Christian K{\"a}stner and Mathias Frisch and Raimund Dachselt and Sven Apel},
  TITLE = {Visual Support for Understanding Product Lines},
  BOOKTITLE = {Proceedings of the 18th International Conference on Program Comprehension (ICPC)},
  YEAR = {2010},
  PAGES = {34--35},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  DOI = {http://dx.doi.org/10.1109/ICPC.2010.15},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/icpc2010_demo.pdf},
  ISSN = {1063-6897},
  ISBN = {978-1-4244-7604-6},
  NOTE = {Demonstration paper},
  ABSTRACT = {
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.}
}

@PHDTHESIS{kaestnerDiss,
  AUTHOR = {Christian K{\"a}stner},
  TITLE = {Virtual Separation of Concerns: Toward Preprocessors 2.0},
  SCHOOL = {University of Magdeburg},
  SELECTED = 1,
  MONTH = MAY,
  PUBLISHER = {Logos Verlag},
  PUBLISHERADDRESS = {Berlin},
  ISBN = {978-3-8325-2527-9},
  NOTE = {Logos Verlag Berlin, isbn 978-3-8325-2527-9},
  DOI = {http://edoc.bibliothek.uni-halle.de/servlets/DocumentServlet?id=8044},
  URL = {http://logos-verlag.de/cgi-bin/engbuchmid?isbn=2527&lng;=deu&id;=},
  PDF = {http://wwwiti.cs.uni-magdeburg.de/iti_db/publikationen/ps/10/diss_kaestner.pdf},
  YEAR = 2010,
  ABSTRACT = {
Conditional compilation with preprocessors such as \emph{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 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 \emph{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.
	}
}

@INPROCEEDINGS{SAK:GPCE10,
  AUTHOR = {Sandro Schulze and Sven Apel and Christian K{\"a}stner},
  TITLE = {Code Clones in Feature-Oriented Software Product Lines},
  BOOKTITLE = {Proceedings of the 9th International Conference on Generative Programming and Component Engineering (GPCE)},
  YEAR = 2010,
  MONTH = OCT,
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/GPCE10_clones.pdf},
  ACM = {http://dl.acm.org/authorize?379692},
  LOCATION = {Eindhoven, The Netherlands},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  PAGES = {103--112},
  NOTE = {Acceptance rate: 31\,\% (18/59)},
  ABSTRACT = {
Some limitations of object-oriented mechanisms are known to
cause code clones (e.g., extension using inheritance). Novel programming
paradigms such as feature-oriented programming (FOP)
aim at alleviating these limitations. However, it is an open issue
whether FOP is really able to avoid code clones or whether it even
facilitates (FOP-specific) clones. To address this issue, we conduct
an empirical analysis on ten feature-oriented software product lines
with respect to code cloning. We found that there is a considerable
amount of clones in feature-oriented software product lines and
that a large fraction of these clones is FOP-specific (i.e., caused by
limitations of feature-oriented mechanisms). Based on our results,
we initiate a discussion on the reasons for FOP-specific clones and
on how to cope with them. We exemplary show how such clones
can be removed by the application of refactoring.
	}
}

@INPROCEEDINGS{ASLK:ISSRE10,
  AUTHOR = {Sven Apel and Wolfgang Scholz and Christian Lengauer and Christian K{\"a}stner},
  TITLE = {Dependences and Interactions in Feature-Oriented Design},
  BOOKTITLE = {Proceedings of the 21st IEEE International Symposium on Software Reliability Engineering (ISSRE)},
  YEAR = 2010,
  MONTH = NOV,
  LOCATION = {San Jose, CA},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  PAGES = {161--170},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/ISSRE10.pdf},
  NOTE = {Acceptance rate: 31\,\% (40/130)},
  ABSTRACT = {Feature-oriented software development (FOSD) aims
at the construction, customization, and synthesis of large-scale
software systems. We propose a novel software design paradigm,
called feature-oriented design, which takes the distinguishing
properties of FOSD into account, especially the clean and consistent
mapping between features and their implementations as well
as the tendency of features to interact inadvertently. We extend
the lightweight modeling language Alloy with support for feature-oriented
design and call the extension FeatureAlloy. By means of
an implementation and four case studies, we demonstrate how
feature-oriented design with FeatureAlloy facilitates separation
of concerns, variability, and reuse of models of individual features
and helps in defining and detecting semantic dependences and
interactions between features.
}
}

@ARTICLE{AKLKML:SCP10,
  AUTHOR = {Sven Apel and Sergiy Kolesnikov and J{\"o}rg Liebig and Christian K{\"a}stner and Martin Kuhlemann and Thomas Leich},
  DOI = {http://dx.doi.org/10.1016/j.scico.2010.07.005},
  TITLE = {Access Control in Feature-Oriented Programming},
  JOURNAL = {Science of Computer Programming (Special Issue on Feature-Oriented Software Development)},
  PUBLISHER = {Elsevier},
  YEAR = 2012,
  MONTH = MAR,
  VOLUME = 77,
  NUMBER = 3,
  PAGES = {174--187},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/SCP_FOSD2010.pdf},
  ABSTRACT = {
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
have not considered access control mechanisms so far. The absence of a well-defined
access control model for FOP breaks encapsulation of feature code and leads to unexpected
program behaviors and inadvertent type errors. We raise awareness of this
problem, propose three feature-oriented access modifiers, and present a corresponding
access modifier model. We offer an implementation of the model on the basis of
a fully-fledged feature-oriented compiler. Finally, by analyzing ten feature-oriented
programs, we explore the potential of feature-oriented modifiers in FOP.
	}
}

@INPROCEEDINGS{ASLK:FOSD10,
  AUTHOR = {Sven Apel and Wolfgang Scholz and Christian Lengauer and Christian K{\"a}stner},
  TITLE = {Language-Independent Reference Checking in Software Product Lines},
  ACM = {http://dl.acm.org/authorize?315789},
  BOOKTITLE = {Proceedings of the Second Workshop on Feature-Oriented Software Development (FOSD)},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  LOCATION = {Eindhoven, The Netherlands},
  ISBN = {978-1-4503-0208-1},
  NOTE = {Acceptance rate: 55\,\% (11/20)},
  MONTH = OCT,
  YEAR = 2010,
  ABSTRACT = {
\emph{Feature-Oriented Software Development} (FOSD) is a paradigm
for the development of software product lines. A challenge
in FOSD is to guarantee that all software systems of
a software product line are correct. Recent work on type
checking product lines can provide a guarantee of type correctness
without generating all possible systems. We generalize
previous results by abstracting from the specifics of
particular programming languages. In a first attempt, we
present a reference-checking algorithm that performs key
tasks of product-line type checking independently of the target
programming language. Experiments with two sample
product lines written in Java and C are encouraging and
give us confidence that this approach is promising.
	},
  PAGES = {64--71},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/FOSD10-ftweezer.pdf}
}

@INPROCEEDINGS{KKHL:FOSD10,
  AUTHOR = {Andy Kenner and Christian K{\"a}stner and Steffen Haase and Thomas Leich},
  TITLE = {{TypeChef}: Toward Type Checking \#ifdef Variability in {C}},
  BOOKTITLE = {Proceedings of the Second Workshop on Feature-Oriented Software Development (FOSD)},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  LOCATION = {Eindhoven, The Netherlands},
  NOTE = {Acceptance rate: 55\,\% (11/20)},
  CROSSCITE = {extended by \cite{KGREOB:OOPSLA11}},
  ISBN = {978-1-4503-0208-1},
  MONTH = OCT,
  YEAR = 2010,
  ABSTRACT = {
Software product lines have gained momentum as an approach to
generate many variants of a program, each tailored to a specific
use case, from a common code base. However, the implementation
of product lines raises new challenges, as potentially millions of
program variants are developed in parallel. In prior work, we and
others have developed product-line--aware type systems to detect
type errors in a product line, without generating all variants. With
\emph{TypeChef}, we build a similar type checker for product lines written
in C that implements variability with \emph{\#ifdef} directives of the
C preprocessor. However, a product-line--aware type system for C
is more difficult than expected due to several peculiarities of the
preprocessor, including lexical macros and unrestricted use of \emph{\#ifdef}
directives. In this paper, we describe the problems faced and our
progress to solve them with \emph{TypeChef}. Although \emph{TypeChef} is still
under development and cannot yet process arbitrary C code, we
demonstrate its capabilities so far with a case study: By type checking
the open-source web server \emph{Boa} with potentially $2^{110}$ variants,
we found type errors in several variants.
	},
  PAGES = {25--32},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/FOSD10-typechef.pdf},
  ACM = {http://dl.acm.org/authorize?315774}
}

@PROCEEDINGS{ABCHKO:FOSD10,
  EDITOR = {Sven Apel and Don Batory and Krzysztof Czarnecki and Florian Heidenreich and Christian K{\"a}stner and Oscar Nierstrasz},
  TITLE = {Proceedings of the Second International Workshop on Feature-Oriented Software Development {(FOSD)}, October 10, 2010, Eindhoven, The Netherlands},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  LOCATION = {Eindhoven, The Netherlands},
  ISBN = {978-1-4503-0208-1},
  MONTH = OCT,
  YEAR = 2010,
  PDF = {http://www.infosun.fim.uni-passau.de/spl/apel/FOSD2010/FOSD2010proceedings.pdf},
  HTTP = {http://portal.acm.org/citation.cfm?id=1868688}
}

@INPROCEEDINGS{KPO:VaMoS11,
  TITLE = {Partial Preprocessing {C} Code for Variability Analysis},
  AUTHOR = {Christian K{\"a}stner and Paolo G. Giarrusso and Klaus Ostermann},
  BOOKTITLE = {Proceedings of the Fifth International Workshop on Variability Modelling of Software-intensive Systems (VaMoS)},
  YEAR = 2011,
  MONTH = JAN,
  LOCATION = {Namur, Belgium},
  PAGES = {137--140},
  ISBN = {978-1-4503-0570-9},
  NOTE = {Acceptance rate: 55\,\% (21/38)},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  ACM = {http://dl.acm.org/authorize?468359},
  ABSTRACT = {
The C preprocessor is commonly used to implement
variability. Given a feature selection, code fragments
can be excluded from compilation with \#ifdef and similar
directives. However, the token-based nature of the C preprocessor
makes variability implementation difficult and errorprone.
Additionally, variability mechanisms are intertwined
with macro definitions, macro expansion, and file inclusion.
To determine whether a code fragment is compiled, the entire
file must be preprocessed. We present a partial preprocessor
that preprocesses file inclusion and macro expansion, but
retains variability information for further analysis.We describe
the mechanisms of the partial preprocessor, provide a full
implementation, and present some initial experimental results.
The partial preprocessor is part of a larger endeavor in
the TypeChef project to check variability implementations
(syntactic correctness, type correctness) in C projects such as
the Linux kernel.			
},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/vamos11.pdf}
}

@INPROCEEDINGS{LKA:AOSD11,
  AUTHOR = {J{\"o}rg Liebig and Christian K{\"a}stner and Sven Apel},
  TITLE = {Analyzing the Discipline of Preprocessor Annotations in 30 Million Lines of {C} Code},
  BOOKTITLE = {Proceedings of the 10th ACM International Conference on Aspect-Oriented Software Development (AOSD)},
  PUBLISHER = {ACM Press},
  PAGES = {191-202},
  MONTH = MAR,
  YEAR = 2011,
  NOTE = {Acceptance rate: 23\,\% (21/92)},
  SELECTED = 1,
  ABSTRACT = {
The C preprocessor cpp is a widely used tool for implementing
variable software. It enables programmers to express
variable code of features that may crosscut the entire implementation
with conditional compilation. The C preprocessor
relies on simple text processing and is independent of the host
language (C, C++, Java, and so on). Language independent
text processing is powerful and expressive|programmers can
make all kinds of annotations in the form of \#ifdefs but
can render unpreprocessed code difficult to process automatically
by tools, such as code aspect refactoring, concern
management, and also static analysis and variability-aware
type checking. We distinguish between disciplined annotations,
which align with the underlying source-code structure,
and undisciplined annotations, which do not align with the
structure and hence complicate tool development. This distinction
raises the question of how frequently programmers
use undisciplined annotations and whether it is feasible to
change them to disciplined annotations to simplify tool development
and to enable programmers to use a wide variety of
tools in the first place. By means of an analysis of 40 mediumsized
to large-sized C programs, we show empirically that
programmers use cpp mostly in a disciplined way: about 85\,\%
of all annotations respect the underlying source-code structure.
Furthermore, we analyze the remaining undisciplined
annotations, identify patterns, and discuss how to transform
them into a disciplined form.
	},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/AOSD11.pdf},
  ACM = {http://dl.acm.org/authorize?473237}
}

@ARTICLE{KATS:TOSEM11,
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Thomas Th{\"u}m and Gunter Saake},
  TITLE = {Type Checking Annotation-Based Product Lines},
  JOURNAL = {ACM Transactions on Software Engineering and Methodology (TOSEM)},
  ABSTRACT = {
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.},
  YEAR = 2012,
  PUBLISHER = {ACM Press},
  SELECTED = 1,
  VOLUME = 21,
  NUMBER = 3,
  PAGES = {14:1--14:39},
  DOI = {http://doi.acm.org/10.1145/2211616.2211617},
  CROSSCITE = {extended version of \cite{KA:ASE08}},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/tosem11.pdf},
  EREADER = {http://www.informatik.uni-marburg.de/~kaestner/tosem11_ereader.pdf}
}

@INPROCEEDINGS{PGKCG:ICSE11,
  AUTHOR = {Mario Pukall and Alexander Grebhahn and Schr{\"o}ter, Reimar and Christian K{\"a}stner and Walter Cazzola and Sebastian G{\"o}tz},
  TITLE = {{JavaAdaptor}: Unrestricted Dynamic Software Updates for {Java}},
  BOOKTITLE = {Proceedings of the 33rd International Conference on Software Engineering (ICSE)},
  NOTE = {Demonstration Track, Acceptance rate: 37\,\% (22/60)},
  YEAR = {2011},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/icse2011_demo_ja.pdf},
  ACM = {http://dl.acm.org/authorize?414157},
  LOCATION = {Waikiki, Honolulu, HI},
  PAGES = {989--991},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  DOI = {http://doi.acm.org/10.1145/1985793.1985970},
  ISBN = {978-1-4503-0445-0}
}

@INPROCEEDINGS{SFFKAD:ICSE11,
  AUTHOR = {Michael Stengel and Janet Feigenspan and Mathias Frisch and Christian K{\"a}stner and Sven Apel and Raimund Dachselt},
  TITLE = {{View Infinity}: A Zoomable Interface for Feature-Oriented Software Development},
  BOOKTITLE = {Proceedings of the 33rd International Conference on Software Engineering  (ICSE)},
  YEAR = {2011},
  NOTE = {Demonstration Track, Acceptance rate: 37\,\% (22/60)},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/icse2011_demo_vi.pdf},
  ACM = {http://dl.acm.org/authorize?414168},
  ISBN = {978-1-4503-0445-0},
  LOCATION = {Waikiki, Honolulu, HI},
  PAGES = {1031--1033},
  DOI = {http://doi.acm.org/10.1145/1985793.1985987},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY}
}

@INPROCEEDINGS{FSPKDKF:EASE11,
  AUTHOR = {Janet Feigenspan and Michael Schulze and Maria Papendieck and Christian K{\"a}stner and Raimund Dachselt and Veit K{\"o}ppen and Mathias Frisch},
  TITLE = {Using Background Colors to Support Program Comprehension in Software Product Lines},
  BOOKTITLE = {Proceedings of the 15th International Conference on Evaluation and Assessment in Software Engineering (EASE)},
  YEAR = 2011,
  PAGES = {66-75},
  PUBLISHER = {Institution of Engineering and Technology},
  NOTE = {Acceptance rate: 39\,\% (20/51)},
  CROSSCITE = {superseeded by \cite{FSPKDKFS:IET12} and \cite{FKALSDPLS:ESE12}},
  ABSTRACT = {
Background: Software product line engineering provides
an effective mechanism to implement variable software.
However, the usage of preprocessors, which is typical in industry,
is heavily criticized, because it often leads to obfuscated code.
Using background colors to support comprehensibility has shown
effective, however, scalability to large software product lines
(SPLs) is questionable. Aim: Our goal is to implement and
evaluate scalable usage of background colors for industrial-sized
SPLs. Method: We designed and implemented scalable concepts
in a tool called FeatureCommander. To evaluate its effectiveness,
we conducted a controlled experiment with a large real-world
SPL with over 160,000 lines of code and 340 features. We
used a within-subjects design with treatments colors and no
colors. We compared correctness and response time of tasks for
both treatments. Results: For certain kinds of tasks, background
colors improve program comprehension. Furthermore, subjects
generally favor background colors. Conclusion: We show that
background colors can improve program comprehension in large
SPLs. Based on these encouraging results, we will continue our
work improving program comprehension in large SPLs.		
	},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/ease2011.pdf}
}

@INPROCEEDINGS{OGKR:ECOOP11,
  TITLE = {Revisiting Information Hiding: Reflections on Classical and Nonclassical Modularity},
  AUTHOR = {Klaus Ostermann and Paolo G. Giarrusso and Christian K{\"a}stner  and Tillmann Rendel},
  BOOKTITLE = {Proceedings of the 25th European Conference on Object-Oriented Programming (ECOOP)},
  NOTE = {Acceptance rate: 26\,\% (26/100)},
  YEAR = 2011,
  SELECTED = 1,
  PAGES = {155-178},
  DOI = {http://dx.doi.org/10.1007/978-3-642-22655-7_8},
  SERIES = {Lecture Notes in Computer Science},
  VOLUME = 6813,
  PUBLISHER = {Springer-Verlag},
  ADDRESS = {Berlin/Heidelberg},
  ABSTRACT = {
What is modularity? Which kind of modularity should developers strive for?
Despite decades of research on modularity, these basic questions have
no definite answer. We submit that the common understanding of
modularity, and in particular its notion of information hiding, is 
deeply rooted in classical logic.
We analyze how classical modularity, based on classical logic, fails to 
address the needs of developers of large software systems, and
encourage researchers to explore alternative visions of
modularity, based on nonclassical logics, and henceforth called
nonclassical
modularity.	
	},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/ecoop11.pdf},
  EREADER = {http://www.informatik.uni-marburg.de/~kaestner/ecoop11_ereader.pdf}
}

@INPROCEEDINGS{AHKR:FOSD11,
  AUTHOR = {Sven Apel and Florian Heidenreich and Christian K{\"a}stner and Marko Rosenm{\"u}ller},
  TITLE = {Third International Workshop on Feature-Oriented Software Development {(FOSD 2011)}},
  BOOKTITLE = {Proceedings of the 15th International Software Product Line Conference (SPLC)},
  PAGES = {337--338},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  LOCATION = {Munich},
  MONTH = AUG,
  YEAR = 2011,
  PDF = {http://www.infosun.fim.uni-passau.de/cl/publications/docs/SPLC2011fosd.pdf},
  HTTP = {http://fosd.net/2011}
}

@INPROCEEDINGS{SRKGAK:SPLC11,
  AUTHOR = {Norbert Siegmund and Marko Rosenm{\"u}ller and Christian K{\"a}stner and Paolo G. Giarrusso and Sven Apel and Sergiy Kolesnikov},
  TITLE = {Scalable Prediction of Non-functional Properties in Software Product Lines},
  BOOKTITLE = {Proceedings of the 15th International Software Product Line Conference (SPLC)},
  YEAR = 2011,
  MONTH = AUG,
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  LOCATION = {Munich},
  ABSTRACT = {
A software product line (SPL) is a family of related software products, from which users can derive a product that fulfills their needs.
Often, users expect a product to have specific non-functional properties, for example, to not exceed a footprint limit or to respond in a given time frame. Unfortunately, it is usually not feasible to generate and measure non-functional properties for each possible product of an SPL in isolation, because an SPL can contain millions of products. Hence, we propose an approach to \emph{estimate} each product's non-functional properties in advance, based on the product's configuration. To this end, we approximate non-functional properties \emph{per features} and per feature interaction. We generate and measure a small set of products and approximated non-functional properties by comparing the measurements. Our approach is implementation independent and language independent. We present three different approaches with different trade-offs regarding accuracy and required number of measurements. With nine case studies, we demonstrate that our approach can predict non-functional properties with an accuracy of 2\%.	
	},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/SPLC11_nfp.pdf},
  PAGES = {160--169},
  NOTE = {Acceptance rate 29\,\% (20/69); \textbf{Best Paper Award}}
}

@INPROCEEDINGS{TKES:SPLC11,
  AUTHOR = {Thomas Th{\"u}m and Christian K{\"a}stner and Sebastian Erdweg and Norbert Siegmund},
  TITLE = {Abstract Features in Feature Modeling},
  BOOKTITLE = {Proceedings of the 15th International Software Product Line Conference (SPLC)},
  YEAR = 2011,
  MONTH = AUG,
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  LOCATION = {Munich},
  ABSTRACT = {
A software product line is a set of program variants, typically generated from a common code base. Feature models describe variability in product lines by documenting features and their valid combinations. In product-line engineering, we need to reason about variability and program variants for many different tasks. For example, given a feature model, we might want to determine the number of all valid feature combinations or detect specific feature combinations for testing. 
However, we found that contemporary reasoning approaches can only reason about feature combinations, not about program variants, because they do not take abstract features into account. Abstract features are features used to structure a feature model that, however, do not have any impact at implementation level. Using existing feature-model reasoning mechanisms for product variants leads to incorrect results.
We raise awareness of the problem of abstract features for different kinds of analyses on feature models. We argue that, in order to reason about program variants, abstract features should be made explicit in feature models. We present a technique based on propositional formulas to reason about program variants. In practice, our technique can save effort that is caused by considering the same program variant multiple times, for example, in product-line testing.
	},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/SPLC11_af.pdf},
  PAGES = {191-200},
  NOTE = {Acceptance rate 29\,\% (20/69)}
}

@INPROCEEDINGS{FALK:ESEM11,
  AUTHOR = {Janet Feigenspan and Sven Apel and J{\"o}rg Liebig and Christian K{\"a}stner},
  TITLE = {Exploring Software Measures to Assess Program Comprehension},
  BOOKTITLE = {Proceedings of the 5th International Symposium on Empirical Software Engineering and Measurement (ESEM)},
  YEAR = 2011,
  LOCATION = {Banff},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  MONTH = SEP,
  ABSTRACT = {
	Software measures are often used to assess program comprehension, although their applicability is discussed controversially. Often, their application is based on plausibility arguments, which however is not sufficient to decide whether and how software measures are good predictors for program comprehension. Our goal is to evaluate whether and how software measures and program comprehension correlate. To this end, we carefully designed an experiment. We used four different measures that are often used to judge the quality of source code: complexity, lines of code, concern attributes, and concern operations. We measured how subjects understood two comparable software systems that differ in their implementation, such that one implementation promised considerable benefits in terms of better software measures. We did not observe a difference in program comprehension of our subjects as the software measures suggested it. To explore how software measures and program comprehension could correlate, we used several variants of computing the software measures. This brought them closer to our observed result, however, not as close as to confirm a relationship between software measures and program comprehension. Having failed to establish a relationship, we present our findings as an open issue to the community and initiate a discussion on the role of software measures as comprehensibility predictors.
	},
  PAGES = {1--10, paper 3},
  NOTE = {Acceptance rate: 31\,\% (33/105)}
}

@INPROCEEDINGS{K:GI2011,
  AUTHOR = {Christian K{\"a}stner},
  TITLE = {{Virtuelle Trennung von Belangen}},
  PUBLISHER = {Gesellschaft f{\"u}r Informatik (GI)},
  SERIES = {Lecture Notes in Informatics},
  VOLUME = {D-11},
  PAGES = {121--130},
  BOOKTITLE = {Ausgezeichnete Informatikdissertationen 2010},
  YEAR = 2011,
  ABSTRACT = {
Bedingte Kompilierung ist ein einfaches und h\"aufig benutztes Mittel zur
Implementierung von Variabilit\"at in Softwareproduktlinien, welches aber aufgrund
negativer Auswirkungen auf Codequalit\"at und Wartbarkeit stark kritisiert wird. Wir
zeigen wie Werkzeugunterst\"utzung -- Sichten, Visualisierung, kontrollierte Annotationen,
Produktlinien-Typsystem -- die wesentlichen Probleme beheben kann und viele
Vorteile einer modularen Entwicklung emuliert. Wir bieten damit eine Alternative zur
klassischen Trennung von Belangen mittels Modulen. Statt Quelltext notwendigerweise
in Dateien zu separieren erzielen wir eine virtuelle Trennung von Belangen durch
entsprechender Werkzeugunterst\"uzung.
	},
  NOTE = {invited paper},
  ISBN = {9783885794158},
  CROSSCITE = {(German summary of \cite{kaestnerDiss})},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/gi11_kurz.pdf}
}

@INPROCEEDINGS{KKS:VariabilityER11,
  TITLE = {Service Variability Patterns},
  AUTHOR = {Ateeq Khan and Christian K{\"a}stner and Veit K\"oppen and Gunter Saake},
  BOOKTITLE = {Proceedings of the ER Workshop on Software Variability Management (Variability@ER)},
  SERIES = {Lecture Notes in Computer Science},
  VOLUME = 6999,
  PAGES = {130--140},
  YEAR = 2011,
  PUBLISHER = {Springer-Verlag},
  ADDRESS = {Berlin/Heidelberg},
  HTTP = {http://www.springerlink.com/content/g22235r0561200m3/}
}

@ARTICLE{SRKKAS:SQJ11,
  AUTHOR = {Norbert Siegmund and Marko Rosenm{\"u}ller and Martin Kuhlemann and Christian K{\"a}stner and Sven Apel and Gunter Saake},
  TITLE = {{SPL Conqueror}: Toward Optimization of Non-functional Properties in Software Product Lines},
  JOURNAL = {Software Quality Journal - Special issue on Quality Engineering for Software Product Lines},
  YEAR = 2011,
  NOTE = {online first},
  ABSTRACT = {
A software product line (SPL) is a family of related programs of a domain.
The programs of an SPL are distinguished in terms of features, which are end-uservisible
characteristics of programs. Based on a selection of features, stakeholders can
derive tailor-made programs that satisfy functional requirements. Besides functional requirements,
different application scenarios raise the need for optimizing non-functional
properties of a variant. The diversity of application scenarios leads to heterogeneous
optimization goals with respect to non-functional properties (e.g., performance vs.
footprint vs. energy optimized variants). Hence, an SPL has to satisfy different and
sometimes contradicting requirements regarding non-functional properties. Usually, the
actually required non-functional properties are not known before product derivation
and can vary for each application scenario and customer. Allowing stakeholders to derive
optimized variants requires to measure non-functional properties after the SPL is
developed. Unfortunately, the high variability provided by SPLs complicates measurement
and optimization of non-functional properties due to a large variant space.
With SPL Conqueror, we provide a holistic approach to optimize non-functional
properties in SPL engineering. We show how non-functional properties can be qualitatively
specified and quantitatively measured in the context of SPLs. Furthermore, we
discuss the variant-derivation process in SPL Conqueror that reduces the effort of computing
an optimal variant. We demonstrate the applicability of our approach by means
of nine case studies of a broad range of application domains (e.g., database management
and operating systems). Moreover, we show that SPL Conqueror is implementation and
language independent by using SPLs that are implemented with different mechanisms,
such as conditional compilation and feature-oriented programming.},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/jsoftwarequality11.pdf},
  HTTP = {http://www.springerlink.com/content/ax788q46h1702j34/},
  DOI = {10.1007/s11219-011-9152-9}
}

@INPROCEEDINGS{ALBLK:FSE11,
  AUTHOR = {Sven Apel and J{\"o}rg Liebig and Benjamin Brandl and Christian Lengauer and Christian K{\"a}stner},
  TITLE = {Semistructured Merge: Rethinking Merge in Revision Control Systems},
  BOOKTITLE = {Proceedings of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE)},
  YEAR = 2011,
  MONTH = SEP,
  LOCATION = {Szeged, Hungary},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  PAGES = {190--200},
  ABSTRACT = {
An ongoing problem in revision control systems is how to resolve
conflicts in a merge of 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 that inherit the strengths of both classes of
systems: generality and expressiveness. The idea is to provide structural
information of the underlying software artifacts---declaratively,
in the form of annotated grammars. This way, a wide variety of languages
can be supported and the information provided can assist the
automatic resolution of two classes of conflicts: ordering conflicts
and semantic conflicts. The former can be resolved independently
of the language and the latter can be resolved using specific conflict
handlers supplied by the user. We have been developing a tool that
supports semistructured merge and conducted an empirical study on
24 software projects developed in Java, C\#, and Python comprising
180 merge scenarios. We found that semistructured merge reduces
the number of conflicts in 60\,\% of the sample merge scenarios by,
on average, 34\,\%. Our study reveals that renaming is challenging
in that it can significantly increase the number of conflicts during
semistructured merge, which we discuss.
},
  NOTE = {Acceptance rate: 17\,\% (34/203)},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/esec11.pdf}
}

@INPROCEEDINGS{ERKO:OOPSLA11,
  AUTHOR = {Sebastian Erdweg and Tillmann Rendel and Christian K{\"a}stner and Klaus Ostermann},
  TITLE = {SugarJ: Library-based Syntactic Language Extensibility},
  BOOKTITLE = {Proceedings of the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)},
  NOTE = {Acceptance rate: 37\,\% (61/166); \textbf{Distinguished Paper Award}},
  ISBN = {978-1-4503-0940-0},
  LOCATION = {Portland, OR},
  PAGES = {391--406},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  MONTH = OCT,
  YEAR = 2011,
  ABSTRACT = {
Existing approaches to extend a programming language with
syntactic sugar often leave a bitter taste, because they cannot
be used with the same ease as the main extension mechanism
of the programming language---libraries. Sugar libraries are
a novel approach for syntactically extending a programming
language within the language. A sugar library is like an ordinary
library, but can, in addition, export syntactic sugar
for using the library. Sugar libraries maintain the composability
and scoping properties of ordinary libraries and are
hence particularly well-suited for embedding a multitude of
domain-specific languages into a host language. They also
inherit the self-applicability of libraries, which means that
the syntax extension mechanism can be applied in the definition
of sugar libraries themselves.

To demonstrate the expressiveness and applicability of
sugar libraries, we have developed SugarJ, a language on
top of Java, SDF and Stratego that supports syntactic extensibility.
SugarJ employs a novel incremental parsing mechanism
that allows changing the syntax within a source file.We
demonstrate SugarJ by five language extensions, including
embeddings of XML and closures in Java, all available as
sugar libraries. We illustrate the utility of self-applicability
by embedding XML Schema, a metalanguage to define
XML languages.
	},
  PDF = {http://www.informatik.uni-marburg.de/~seba/publications/sugarj.pdf},
  DOI = {http://doi.acm.org/10.1145/2048066.2048099}
}

@INPROCEEDINGS{EKRKOV:OOPSLA11:Demo,
  AUTHOR = {Erdweg, Sebastian and Kats, Lennart C.L. and Rendel, Tillmann and K\"{a}stner, Christian and Ostermann, Klaus and Visser, Eelco},
  TITLE = {Library-Based Model-Driven Software Development with {SugarJ}},
  BOOKTITLE = {Companion of the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)},
  YEAR = {2011},
  ISBN = {978-1-4503-0942-4},
  LOCATION = {Portland, OR},
  PAGES = {17--18},
  NUMPAGES = {2},
  DOI = {http://doi.acm.org/10.1145/2048147.2048156},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  NOTE = {Demonstration paper},
  CROSSCITE = {demonstration accompying \cite{ERKO:OOPSLA11} and \cite{ELRLPV:GPCE11}}
}

@INPROCEEDINGS{EKRKOV:OOPSLA11:Poster,
  AUTHOR = {Erdweg, Sebastian and Kats, Lennart C.L. and Rendel, Tillmann and K\"{a}stner, Christian and Ostermann, Klaus and Visser, Eelco},
  TITLE = {{SugarJ}: Library-Based Language Extensibility},
  BOOKTITLE = {Companion of the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)},
  YEAR = {2011},
  ISBN = {978-1-4503-0942-4},
  LOCATION = {Portland, OR},
  PAGES = {187--188},
  NUMPAGES = {2},
  DOI = {http://doi.acm.org/10.1145/2048147.2048199},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  NOTE = {Poster},
  CROSSCITE = {poster accompying \cite{ERKO:OOPSLA11} and \cite{ELRLPV:GPCE11}}
}

@INPROCEEDINGS{KGREOB:OOPSLA11,
  AUTHOR = {Christian K{\"a}stner and Paolo G. Giarrusso and Tillmann Rendel and Sebastian Erdweg and Klaus Ostermann and Thorsten Berger},
  TITLE = {Variability-Aware Parsing in the Presence of Lexical Macros and Conditional Compilation},
  BOOKTITLE = {Proceedings of the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)},
  NOTE = {Acceptance rate: 37\,\% (61/166)},
  LOCATION = {Portland, OR},
  PAGES = {805--824},
  DOI = {http://doi.acm.org/10.1145/2048066.2048128},
  ISBN = {978-1-4503-0940-0},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  MONTH = OCT,
  YEAR = 2011,
  SELECTED = 1,
  ABSTRACT = {
In many projects, lexical preprocessors are used to manage
different variants of the project (using conditional compilation)
and to define compile-time code transformations (using
macros). Unfortunately, while being a simply way to implement
variability, conditional compilation and lexical macros
hinder automatic analysis, even though such analysis would
be urgently needed to combat variability-induced complexity.
To analyze code with its variability, we need to parse
it without preprocessing it. However, current parsing solutions
use heuristics, support only a subset of the language, or
suffer from exponential explosion. As part of the TypeChef
project, we contribute a novel variability-aware parser that
can parse unpreprocessed code without heuristics in practicable
time. Beyond the obvious task of detecting syntax errors,
our parser paves the road for further analysis, such as
variability-aware type checking. We implement variabilityaware
parsers for Java and GNU C and demonstrate practicability
by parsing the product line MobileMedia and the
entire X86 architecture of the Linux kernel with 6065 variable
features.
	},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/oopsla11_typechef.pdf}
}

@INPROCEEDINGS{FPKFD:SPLC11,
  TITLE = {{FeatureCommander}: Colorful \#ifdef World},
  AUTHOR = {Janet Feigenspan and Maria Papendieck and Christian K{\"a}stner and Mathias Frisch and Raimund Dachselt},
  BOOKTITLE = {Proceedings of the 15th International Software Product Line Conference (SPLC), second volume (Demonstration)},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  LOCATION = {Munich},
  YEAR = 2011,
  MONTH = SEP,
  URL = {http://www.informatik.uni-marburg.de/~kaestner/SPLC11_demo.pdf},
  DOI = {http://doi.acm.org/10.1145/2019136.2019192},
  PAGES = {48:1--48:2},
  ISBN = {978-1-4503-0789-5}
}

@INPROCEEDINGS{AKO:FOSD11,
  TITLE = {The Road to Feature Modularity?},
  AUTHOR = {Christian K{\"a}stner and Sven Apel and Klaus Ostermann},
  BOOKTITLE = {Proceedings of the Third Workshop on Feature-Oriented Software Development (FOSD)},
  YEAR = 2011,
  MONTH = SEP,
  LOCATION = {Munich},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  PAGES = {5:1--5:8},
  ISBN = {978-1-4503-0789-5},
  DOI = {http://doi.acm.org/10.1145/2019136.2019142},
  SELECTED = 1,
  ABSTRACT = {
Modularity of feature representations has been a long standing
goal of feature-oriented software development. While
some researchers regard feature modules and corresponding
composition mechanisms as a modular solution, other researchers
have challenged the notion of feature modularity
and pointed out that most feature-oriented implementation
mechanisms lack proper interfaces and support neither modular
type checking nor separate compilation. We step back
and reflect on the feature-modularity discussion. We distinguish
two notions of modularity, \emph{cohesion} without interfaces
and \emph{information hiding} with interfaces, and point out the
different expectations that, we believe, are the root of many
heated discussions. We discuss whether feature interfaces
should be desired and weigh their potential benefits and
costs, specifically regarding crosscutting, granularity, feature
interactions, and the distinction between closed-world and
open-world reasoning. Because existing evidence for and
against feature modularity and feature interfaces is shaky
and inconclusive, more research is needed, for which we
outline possible directions.	
	},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/FOSD11-modularity.pdf}
}

@INPROCEEDINGS{ELRLPV:GPCE11,
  AUTHOR = {Sebastian Erdweg and Lennart C. L. Kats and Tillmann Rendel and
               Christian K{\"a}stner and Klaus Ostermann and Eelco Visser},
  TITLE = {Growing a Language Environment with Editor Libraries},
  BOOKTITLE = {Proceedings of the 10th International Conference on Generative Programming and Component Engineering (GPCE)},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  LOCATION = {Portland, OR},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/gpce11.pdf},
  NOTE = {Acceptance rate: 31\,\% (18/58)},
  PAGES = {167--176},
  DOI = {http://doi.acm.org/10.1145/2047862.2047891},
  ISBN = {978-1-4503-0689-8},
  YEAR = {2011},
  MONTH = OCT,
  ABSTRACT = {
Large software projects consist of code written in a multitude of different
(possibly domain-specific) languages, which are often deeply interspersed even
in single files. While many proposals exist on how to integrate languages
semantically and syntactically, the question of how to support this scenario in
integrated development environments (IDEs) remains open: How can standard IDE
services, such as syntax highlighting, outlining, or reference resolving, be
provided in an extensible and compositional way, such that an open mix of
languages is supported in a single file?

Based on our library-based syntactic extension language for Java, SugarJ, we
propose to make IDEs extensible by organizing editor services in editor
libraries. Editor libraries are libraries written in the object language,
SugarJ, and hence activated and composed through regular import statements on a
file-by-file basis.  We have implemented an IDE for editor libraries on top of
SugarJ and the Eclipse-based Spoofax language workbench.  We have validated
editor libraries by evolving this IDE into a fully-fledged and schema-aware XML
editor as well as an extensible Latex editor, which we used for writing this
paper.
  }
}

@TECHREPORT{KKAS:MD11,
  AUTHOR = {Martin Kuhlemann and Christian K{\"a}stner and Sven Apel and Gunter Saake},
  TITLE = {An Algebra for Refactoring and Feature-Oriented Programming},
  INSTITUTION = {School of Computer Science, University of Magdeburg},
  YEAR = {2011},
  NUMBER = {FIN-006-2011},
  URL = {http://www.cs.uni-magdeburg.de/fin_media/downloads/forschung/technical_reports_und_preprints/2011/TechReport06-p-2138.pdf}
}

@TECHREPORT{KDO:MR11,
  AUTHOR = {Christian K{\"a}stner and Alexander Dreiling and Klaus Ostermann},
  TITLE = {Variability Mining with {LEADT}},
  YEAR = {2011},
  INSTITUTION = {Department of Mathematics and Computer Science, Philipps University Marburg},
  MONTH = SEP,
  NUMBER = {01/2011},
  ABSTRACT = {
	Software product line engineering is an efficient means to generate a set of tailored software products from a common implementation. 
However, adopting a product-line approach poses a major challenge and significant risks, since typically legacy code must be migrated toward a product line. Our aim is to lower the adoption barrier by providing semiautomatic tool support---called \emph{variability mining}---to support developers in locating, documenting, and extracting implementations of product-line features from legacy code. Variability mining combines prior work on concern location, reverse engineering, and variability-aware type systems, but is tailored specifically for the use in product lines. Our work extends prior work in three important aspects: (1) we provide a \emph{consistency indicator} based on a variability-aware type system, (2) we mine features at a \emph{fine level of granularity}, and (3) we exploit \emph{domain knowledge} about the relationship between features when available. With a quantitative study, we demonstrate that variability mining can efficiently support developers in locating features.
	},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/tr_leadt2011.pdf},
  HTTP = {http://www.uni-marburg.de/fb12/forschung/berichte/berichteinformtk}
}

@ARTICLE{PKCGGSS:SPE12,
  AUTHOR = {Mario Pukall and Christian K{\"a}stner and Walter Cazzola and Sebastian G{\"o}tz and Alexander Grebhahn and Reimar Schr\"oter and Gunter Saake},
  TITLE = {{JavAdaptor}: Flexible Runtime Updates of {Java} Applications},
  JOURNAL = {Software: Practice and Experience},
  YEAR = 2012,
  NOTE = {online first},
  ABSTRACT = {
Software is changed frequently during its life cycle. New requirements come and bugs must be fixed.
To update an application it usually must be stopped, patched, and restarted. This causes time periods of
unavailability which is always a problem for highly available applications. Even for the development of
complex applications restarts to test new program parts can be time consuming and annoying. Thus, we
aim at dynamic software updates to update programs at runtime. There is a large body of research on
dynamic software updates, but so far, existing approaches have shortcomings either in terms of flexibility or
performance. In addition, some of them depend on specific runtime environments and dictate the program?s
architecture. We present JavAdaptor, the first runtime update approach based on Java that (a) offers
flexible dynamic software updates, (b) is platform independent, (c) introduces only minimal performance
overhead, and (d) does not dictate the program architecture. JavAdaptor combines schema changing class
replacements by class renaming and caller updates with Java HotSwap using containers and proxies. It runs
on top of all major standard Java virtual machines.We evaluate our approach?s applicability and performance
in non-trivial case studies and compare it to existing dynamic software update approaches.	
	},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/SPE12_JavAdaptor.pdf},
  HTTP = {http://onlinelibrary.wiley.com/doi/10.1002/spe.2107/abstract},
  DOI = {10.1002/spe.2107}
}

@ARTICLE{AKL:TSE12,
  AUTHOR = {Sven Apel and Christian K{\"a}stner and Christian Lengauer},
  TITLE = {Language-Independent and Automated Software Composition: The {FeatureHouse} Experience},
  JOURNAL = {IEEE Transactions on Software Engineering (TSE)},
  YEAR = 2012,
  NOTE = {to appear; submitted 21 Oct 2010, accepted 29 Nov 2011},
  ABSTRACT = {
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 \emph{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, Alloy, and JavaCC. A substantial number of case studies demonstrate the practicality and scalability of our approach and reveal insights into the properties that a language must have in order to be ready for superimposition. We discuss perspectives of our approach and demonstrate how we extended FeatureHouse with support for XML languages (in particular, XHTML, XMI/UML, and Ant) and alternative composition approaches (in particular, aspect weaving). Rounding off our previous work, we provide here a holistic view of the FeatureHouse approach based on rich experience with numerous languages and case studies and reflections on several years of research.},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/tse_fh.pdf},
  HTTP = {http://doi.ieeecomputersociety.org/10.1109/TSE.2011.120},
  SELECTED = 1
}

@INPROCEEDINGS{SKKABRS:ICSE12,
  AUTHOR = {Norbert Siegmund and Sergiy S. Kolesnikov and Christian K{\"a}stner and Sven Apel and Don Batory and Marko Rosenm{\"u}ller and Gunter Saake},
  TITLE = {Predicting Performance via Automated Feature-Interaction Detection},
  BOOKTITLE = {Proceedings of the 34th International Conference on Software Engineering (ICSE)},
  YEAR = 2012,
  NOTE = {Acceptance rate 21\,\% (87/408)},
  PAGES = {167--177},
  ISBN = {978-1-4673-1067-3},
  LOCATION = {Zurich},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  ABSTRACT = { 
Customizable programs and program families
provide user-selectable features 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. The challenge is predicting performance
accurately when features interact. An interaction
occurs when a feature combination has an unexpected influence
on performance. We present a method that automatically
detects performance 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, compression libraries, and web server)
using different configuration techniques (e.g., configuration files
and preprocessor flags). Results show, on average, a prediction
accuracy of 95\,\%.		
	},
  URL = {http://www.informatik.uni-marburg.de/~kaestner/icse12.pdf},
  SELECTED = 1
}

@ARTICLE{K:IT12,
  AUTHOR = {Christian K\"astner},
  TITLE = {Virtual Separation of Concerns: Toward Preprocessors 2.0},
  JOURNAL = {it--Information Technology},
  YEAR = 2012,
  VOLUME = 54,
  NUMBER = 1,
  DOI = {http://www.oldenbourg-link.com/doi/abs/10.1524/itit.2012.0662},
  URL = {http://it-information-technology.de/},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/itit12.pdf},
  PAGES = {42--46},
  CROSSCITE = {invited summary of \cite{kaestnerDiss}}
}

@INPROCEEDINGS{FKLAH:ICPC2012,
  AUTHOR = {Janet Feigenspan and Christian K{\"a}stner and J{\"o}rg Liebig and Sven Apel and Stefan Hanenberg},
  TITLE = {Measuring Programming Experience},
  BOOKTITLE = {Proceedings of the 20th International Conference on Program Comprehension (ICPC)},
  YEAR = {2012},
  PUBLISHER = {IEEE Computer Society},
  ADDRESS = {Los Alamitos, CA},
  NOTE = {acceptance rate: 41\,\% (21/51)},
  PAGES = {73--82},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/icpc12.pdf},
  ABSTRACT = {
Programming experience is an important confounding
parameter in controlled experiments regarding program
comprehension. In literature, ways to measure or control programming
experience vary. Often, researchers neglect it or do
not specify how they controlled it.We set out to find a well-defined
understanding of programming experience and a way to measure
it. From published comprehension experiments, we extracted
questions that assess programming experience. In a controlled experiment,
we compare the answers of 128 students to these questions
with their performance in solving program-comprehension
tasks. We found that self estimation seems to be a reliable way
to measure programming experience. Furthermore, we applied
exploratory factor analysis to extract a model of programming
experience. With our analysis, we initiate a path toward measuring
programming experience with a valid and reliable tool,
so that we can control its influence on program comprehension.
}
}

@ARTICLE{FSPKDKFS:IET12,
  AUTHOR = {Janet Feigenspan and Michael Schulze and Maria Papendieck and Christian K{\"a}stner and Raimund Dachselt and Veit K\"oppen and Mathias Frisch and Gunter Saake},
  TITLE = {Supporting Program Comprehension in Large Preprocessor-Based Software Product Lines},
  JOURNAL = {IET Software},
  YEAR = 2012,
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/ietsoftw12.pdf},
  NOTE = {to appear; accepted 11 Apr 2012},
  ABSTRACT = {
Background: Software product line engineering provides an effective mechanism to implement variable software.
However, the usage of preprocessors to realize variability, which is typical in industry, is heavily criticized, because
it often leads to obfuscated code. Using background colours to highlight preprocessor statements to support
comprehensibility has shown effective, however, scalability to large software product lines (SPLs) is questionable.
Aim: Our goal is to implement and evaluate scalable usage of background colours for industrial-sized SPLs. Method:
We designed and implemented scalable concepts in a tool called FeatureCommander. To evaluate its effectiveness, we
conducted a controlled experiment with a large real-world SPL with over 99,000 lines of code and 340 features. We
used a within-subjects design with treatments colours and no colours. We compared correctness and response time of
tasks for both treatments. Results: For certain kinds of tasks, background colours improve program comprehension.
Furthermore, subjects generally favour background colours compared to no background colours. Additionally, subjects
who worked with background colours had to use the search functions less frequently. Conclusion: We show that
background colours can improve program comprehension in large SPLs. Based on these encouraging results, we will
continue our work on improving program comprehension in large SPLs.
},
  CROSSCITE = {extended version of \cite{FSPKDKF:EASE11}, see also \cite{FKALSDPLS:ESE12}}
}

@ARTICLE{FKALSDPLS:ESE12,
  AUTHOR = {Janet Feigenspan and Christian K{\"a}stner and Sven Apel and J{\"o}rg Liebig and Michael Schulze and Raimund Dachselt and Maria
Papendieck and Thomas Leich and Gunter Saake},
  TITLE = {Do Background Colors Improve Program Comprehension in the \#ifdef Hell?},
  JOURNAL = {Empirical Software Engineering},
  YEAR = 2012,
  NOTE = {to appear; accepted 12 Apr 2012},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/ese12.pdf},
  DOI = {http://dx.doi.org/10.1007/s10664-012-9208-x},
  ABSTRACT = {
Software-product-line engineering aims at the development of variable
and reusable software systems. In practice, software product lines are
often implemented with preprocessors. Preprocessor directives are easy to use,
and many mature tools are available for practitioners. However, preprocessor
directives have been heavily criticized in academia and even referred to
as ``\#ifdef hell'', because they introduce threats to program comprehension
and correctness. There are many voices that suggest to use other implementation
techniques instead, but these voices ignore the fact that a transition
from preprocessors to other languages and tools is tedious, erroneous, and expensive
in practice. Instead, we and others propose to increase the readability
of preprocessor directives by using background colors to highlight source code
annotated with ifdef directives. In three controlled experiments with over 70
subjects in total, we evaluate whether and how background colors improve
program comprehension in preprocessor-based implementations. Our results
demonstrate that background colors have the potential to improve program
comprehension, independently of size and programming language of the underlying
product. Additionally, we found that subjects generally favor background
colors. We integrate these and other findings in a tool called FeatureCommander,
which facilitates program comprehension in practice and which can serve
as a basis for further research.},
  SELECTED = 1
}

@TECHREPORT{TAKKSS:MD12,
  AUTHOR = {Thomas Th{\"u}m and Sven Apel and Christian K{\"a}stner and Martin Kuhlemann and Ina Schaefer and Gunter Saake},
  TITLE = {Analysis Strategies for Software Product Lines},
  NUMBER = {FIN-004-2012},
  INSTITUTION = {School of Computer Science, University of Magdeburg},
  MONTH = APR,
  YEAR = 2012,
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/tr_analysis12.pdf},
  ABSTRACT = {
Software-product-line engineering has gained considerable momentum in recent years, both in
industry and in academia. A software product line is a set of software products that share a
common set of features. Software product lines challenge traditional analysis techniques, such as
type checking, testing, and formal verification, in their quest of ensuring correctness and reliability
of software. Simply creating and analyzing all products of a product line is usually not feasible,
due to the potentially exponential number of valid feature combinations. Recently, researchers
began to develop analysis techniques that take the distinguishing properties of software product
lines into account, for example, by checking feature-related code in isolation or by exploiting
variability information during analysis. The emerging field of product-line analysis techniques is
both broad and diverse such that it is difficult for researchers and practitioners to understand
their similarities and differences (e.g., with regard to variability awareness or scalability), which
hinders systematic research and application. We classify the corpus of existing and ongoing work
in this field, we compare techniques based on our classification, and we infer a research agenda.
A short-term benefit of our endeavor is that our classification can guide research in product-line
analysis and, to this end, make it more systematic and efficient. A long-term goal is to empower
developers to choose the right analysis technique for their needs out of a pool of techniques with
different strengths and weaknesses.
	}
}

@TECHREPORT{KOE:MR12,
  AUTHOR = {Christian K{\"a}stner and Klaus Ostermann and Sebastian Erdweg},
  TITLE = {A Variability-Aware Module System},
  INSTITUTION = {Department of Mathematics and Computer Science, Philipps University Marburg},
  NUMBER = {01/2012},
  MONTH = APR,
  YEAR = 2012,
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/tr_modulesys12.pdf},
  NOABSTRACT = {
Module systems enable a divide and conquer strategy to software development.
To implement compile-time variability in software product lines, modules
can be composed in different combinations. However, this way variability
dictates a dominant decomposition. Instead, we introduce a variability-aware
module system that supports compile-time variability \emph{inside} a module and its
interface. This way, each module can be considered a product line that can
be type checked in isolation. Variability can crosscut multiple modules. The
module system breaks with the antimodular tradition of a global variability
model in product-line development and provides a path toward software
ecosystems and product lines of product lines developed in an open fashion.
We discuss the design and implementation of such a module system on a core
calculus and provide an implementation for C, which we use to type check
the open source product line Busybox with 811~compile-time options.
},
  CROSSCITE = {published formally as \cite{KOE:OOPSLA12}}
}

@INPROCEEDINGS{KOE:OOPSLA12,
  AUTHOR = {Christian K{\"a}stner and Klaus Ostermann and Sebastian Erdweg},
  TITLE = {A Variability-Aware Module System},
  BOOKTITLE = {Proceedings of the 27th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)},
  NOTE = {to appear, acceptance rate: 25\,\% (?/228)},
  LOCATION = {Tucson, AZ},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/oopsla12.pdf},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  MONTH = OCT,
  YEAR = 2012,
  SELECTED = 1,
  ABSTRACT = {
Module systems enable a divide and conquer strategy to software development.
To implement compile-time variability in software product lines, modules
can be composed in different combinations. However, this way variability
dictates a dominant decomposition. Instead, we introduce a variability-aware
module system that supports compile-time variability \emph{inside} a module and its
interface. This way, each module can be considered a product line that can
be type checked in isolation. Variability can crosscut multiple modules. The
module system breaks with the antimodular tradition of a global variability
model in product-line development and provides a path toward software
ecosystems and product lines of product lines developed in an open fashion.
We discuss the design and implementation of such a module system on a core
calculus and provide an implementation for C, which we use to type check
the open source product line Busybox with 811~compile-time options.
},
  CROSSCITE = {superseeds \cite{KOE:MR12}}
}

@ARTICLE{TKBMSL:SCP12,
  AUTHOR = {Thomas Th{\"u}m and Christian K{\"a}stner and Fabian Benduhn and Jens Meinicke and Gunter Saake and Thomas Leich},
  TITLE = {{FeatureIDE}: An Extensible Framework for Feature-Oriented Software Development},
  JOURNAL = {Science of Computer Programming},
  YEAR = {2012},
  NOTE = {to appear; accepted 2012-06-07},
  DOI = {http://dx.doi.org/10.1016/j.scico.2012.06.002},
  ABSTRACT = {FeatureIDE is an open-source framework for feature-oriented software development (FOSD) based on Eclipse. FOSD is a paradigm for the construction, customization, and synthesis of software systems. Code artifacts are mapped to features, and a customized software system can be generated given a selection of features. The set of software systems that can be generated is called a software product line (SPL). FeatureIDE supports several FOSD implementation techniques such as feature-oriented programming, aspect-oriented programming, delta-oriented programming, and preprocessors. All phases of FOSD are supported in FeatureIDE, namely domain analysis, requirements analysis, domain implementation, and software generation.}
}

@INPROCEEDINGS{GOERK:OOPSLA12:Poster,
  AUTHOR = {Paolo  G. Giarrusso and Klaus Ostermann and Michael Eichberg and Tillmann Rendel and Christian K\"{a}stner},
  TITLE = {Reifying and Optimizing Collection Queries for Modularity},
  BOOKTITLE = {Companion of the 27th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)},
  YEAR = {2011},
  LOCATION = {Tucson, AZ},
  PUBLISHER = {ACM Press},
  ADDRESS = {New York, NY},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/oopsla12_poster.pdf},
  NOTE = {Poster; to appear; accepted 2012-07-27}
}

@ARTICLE{SRKGAK:IST12,
  AUTHOR = {Norbert Siegmund and Marko Rosenm{\"u}ller and Christian K{\"a}stner and Paolo G. Giarrusso and Sven Apel and Sergiy S. Kolesnikov},
  TITLE = {Scalable Prediction of Non-functional Properties in Software Product Lines: Footprint and Memory Consumption},
  JOURNAL = {Information and Software Technology (IST)},
  YEAR = 2012,
  NOTE = {to appear; accepted 2012-07-30},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/IST12.pdf},
  ABSTRACT = {
Context: A software product line is a family of related software products,
typically created from a set of common assets. Users select features to derive
a product that fulfills their needs. Users often expect a product to have
specific non-functional properties, such as a small footprint or a bounded
response time. Because a product line may have an exponential number of
products with respect to its features, it is usually not feasible to generate
and measure non-functional properties for each possible product.
Objective: Our overall goal is to derive optimal products with respect to
non-functional requirements by showing customers which features must be
selected.
Method: We propose an approach to predict a product?s non-functional
properties based on the product?s feature selection. We aggregate the influence
of each selected feature on a non-functional property to predict a
product?s properties. We generate and measure a small set of products and,
by comparing measurements, we approximate each feature?s influence on
the non-functional property in question. As a research method, we conducted
controlled experiments and evaluated prediction accuracy for the
non-functional properties footprint and main-memory consumption. But,
in principle, our approach is applicable for all quantifiable non-functional
properties.
Results: With nine software product lines, we demonstrate that our approach
predicts the footprint with an average accuracy of 94\,\%, and an accuracy
of over 99\,\% on average if feature interactions are known. In a further
series of experiments, we predicted main memory consumption of six customizable
programs and achieved an accuracy of 89\,\% on average.
Conclusion: Our experiments suggest that, with only few measurements,
it is possible to accurately predict non-functional properties of products of
a product line. Furthermore, we show how already little domain knowledge
can improve predictions and discuss trade-offs between accuracy and required
number of measurements. With this technique, we provide a basis for many
reasoning and product-derivation approaches.
	}
}

@INPROCEEDINGS{ERKO:SLE12,
  AUTHOR = {Sebastian Erdweg and Tillmann Rendel and Christian K{\"a}stner and Klaus Ostermann},
  TITLE = {Layout-Sensitive Generalized Parsing},
  BOOKTITLE = {Proceedings of the Conference on Software Language Engineering (SLE)},
  YEAR = 2012,
  NOTE = {to appear, acceptance rate: 32\,\% (20/62)},
  PDF = {http://www.informatik.uni-marburg.de/~kaestner/sle12.pdf},
  ABSTRACT = {
The theory of context-free languages is well-understood and context-free parsers can be used as off-the-shelf tools in practice. In particular, to use a context-free parser framework, a user does not need to understand its internals but can specify a language declaratively as a grammar. However, many languages in practice are not context-free. One particularly important class of such languages is layout-sensitive languages, in which the structure of code depends on indentation and whitespace. For example, Python, Haskell, F\#, and Markdown use indentation instead of curly braces to determine the block structure of code. Their parsers (and lexers) are not declaratively specified but hand-tuned to account for layout-sensitivity. 
 To support \emph{declarative} specifications of layout-sensitive languages, we propose a parsing framework in which a user can annotate layout in a grammar as constraints on the relative positioning of tokens in the parsed subtrees. For example, a user can declare that a block consists of statements that all start on the same column. We have integrated layout constraints into SDF and implemented a layout-sensitive generalized parser as an extension of generalized LR parsing. We evaluate the correctness and performance of our parser by parsing 33290 open-source Haskell files. Layout-sensitive generalized parsing is easy to use, and its performance overhead compared to layout-insensitive parsing is small enough for most practical applications.
	}
}

@INPROCEEDINGS{SKJA:FOSD12,
  AUTHOR = {Janet Siegmund and Christian K{\"a}stner and J{\"o}rg Liebig and Sven Apel},
  TITLE = {Comparing Program Comprehension of Physically and Virtually Separated Concerns},
  BOOKTITLE = {Proceedings of the Fourth Workshop on Feature-Oriented Software Development (FOSD)},
  YEAR = 2012,
  NOTE = {to appear},
  ABSTRACT = {
It is common believe that separating source code along concerns
or features improves program comprehension of source
code. However, empirical evidence is mostly missing. In this
paper, we design a controlled experiment to evaluate that
believe for feature-oriented programming based on maintenance
tasks with human participants. We validate our
experiment with a pilot study, which already preliminarily
confirms that students use different strategies to complete
maintenance tasks.	
	}
}

@INPROCEEDINGS{KREPARO:FOSD12,
  AUTHOR = {Christian K{\"a}stner and Alexander von Rhein and Sebastian Erdweg and Jonas Pusch and Sven Apel and Tillmann Rendel and Klaus Ostermann},
  TITLE = {Toward Variability-Aware Testing},
  BOOKTITLE = {Proceedings of the Fourth Workshop on Feature-Oriented Software Development (FOSD)},
  YEAR = 2012,
  NOTE = {to appear},
  ABSTRACT = {We investigate how to execute a unit test in all configurations of a product line without generating each product in isolation in a brute-force fashion. Learning from variability-aware analyses, we (a) design and implement a variability-aware interpreter and (b) reencode variability of the product line to simulate the test cases with a model checker. The interpreter internally reasons about variability, executing paths not affected by variability only once for the whole product line. The model checker achieves similar results by reusing powerful off-the-shelf analyses. We experimented with a prototype implementation for each strategy. We compare both strategies and discuss trade-offs and future directions.}
}

@INPROCEEDINGS{SBAKLLS:FSENIER12,
  AUTHOR = {Janet Siegmund and Andr{\'e} Brechmann and Sven Apel and Christian K{\"a}stner and J{\"o}rg Liebig and Thomas Leich and Gunter Saake},
  TITLE = {Toward Measuring Program Comprehension with Functional Magnetic Resonance Imaging},
  BOOKTITLE = {Proceedings of the 20th International Symposium on Foundations of Software Engineering -- New Ideas Track (FSE20-NIER)},
  YEAR = 2012,
  NOTE = {to appear, acceptance rate: 20\,\% (12/59)},
  ABSTRACT = {
Program comprehension is an often evaluated, internal cognitive process. In neuroscience, \emph{functional magnetic resonance (fMRI)} imaging is used to visualize such internal cognitive processes. We propose an experimental design to measure program comprehension based on fMRI. In the long run, we hope to answer questions like \emph{What distinguishes good programmers from bad programmers?} or \emph{What makes a good programmer?}
	}
}


This file has been generated by bibtex2html 1.79

Zuletzt aktualisiert: 20.08.2012 · kaestnec

 
 
 
Fb. 12 - Mathematik und Informatik

Programmiersprachen und Softwaretechnik, Hans-Meerwein-Straße, D-35032 Marburg
Tel. +49 6421/28-21513, Fax +49 6421/28-25419, E-Mail: dinklage@informatik.uni-marburg.de

URL dieser Seite: http://www.uni-marburg.de/fb12/ps/team/kaestner_bib.html

Impressum | Datenschutz