Virtual Separation of Concerns: Toward Preprocessors 2.0

Abstract Conditional compilation with preprocessors like cpp is a simple but effective means to implement variability. By annotating code fragments with #ifdef and #endif directives, different program variants with or without these 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. We show how simple tool support — views, visualizations, disciplined annotations, and variability-aware type systems — can address these problems and emulate some benefits of modularized implementations. Instead of separating source code into files, we pursue a “virtual separation of concerns”. Zusammenfassung Bedingte Kompilierung ist ein einfaches und häufig benutztes Mittel zur Implementierung von Variabilität in Softwareproduktlinien, welches aber aufgrund negativer Auswirkungen auf Codequalität und Wartbarkeit stark kritisiert wird. Wir zeigen wie Werkzeugunterstützung — 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 entsprechende Werkzeugunterstüzung.

[1]  Renaud Pawlak Spoon: Compile-time Annotation Processing for Middleware , 2006, IEEE Distributed Systems Online.

[2]  Sven Apel,et al.  An Algebra for Features and Feature Composition , 2008, AMAST.

[3]  Carsten Sinz,et al.  Configuration Lifting: Verification meets Software Configuration , 2008, 2008 23rd IEEE/ACM International Conference on Automated Software Engineering.

[4]  Don S. Batory,et al.  Feature Models, Grammars, and Propositional Formulas , 2005, SPLC.

[5]  Andrew C. Myers,et al.  Scalable extensibility via nested inheritance , 2004, OOPSLA.

[6]  Mira Mezini,et al.  Variability management with feature-oriented programming and aspects , 2004, SIGSOFT '04/FSE-12.

[7]  Gunter Saake,et al.  Measuring Non-Functional Properties in Software Product Line for Product Derivation , 2008, 2008 15th Asia-Pacific Software Engineering Conference.

[8]  Alejandra Garrido,et al.  Program refactoring in the presence of preprocessor directives , 2005 .

[9]  Krzysztof Czarnecki,et al.  The Variability Model of The Linux Kernel , 2010, VaMoS.

[10]  Sven Apel,et al.  A model of refactoring physically and virtually separated features , 2009, GPCE '09.

[11]  William R. Cook,et al.  Fitting the pieces together: a machine-checked model of safe composition , 2009, ESEC/FSE '09.

[12]  Adam Kiezun,et al.  Advanced Refactoring in the Eclipse JDT: Past, Present, and Future , 2007, WRT.

[13]  William R. Cook,et al.  Object-Oriented Programming Versus Abstract Data Types , 1990, REX Workshop.

[14]  Harold Ossher,et al.  Subject-oriented programming: a critique of pure objects , 1993, OOPSLA '93.

[15]  Roberto Erick Lopez-Herrejon,et al.  Evaluating Support for Features in Advanced Modularization Technologies , 2005, ECOOP.

[16]  Ilka Philippow,et al.  Details of formalized relations in feature models using OCL , 2003, 10th IEEE International Conference and Workshop on the Engineering of Computer-Based Systems, 2003. Proceedings..

[17]  Mark Chu-Carroll,et al.  Visual separation of concerns through multidimensional program storage , 2003, AOSD '03.

[18]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[19]  Charles Simonyi,et al.  Intentional software , 2006, OOPSLA '06.

[20]  Harold Ossher,et al.  On the Need for On-Demand Remodularization , 2000 .

[21]  Antonio Ruiz Cortés,et al.  Automated Reasoning on Feature Models , 2005, Seminal Contributions to Information Systems Engineering.

[22]  Mark A. Linton,et al.  Implementing relational views of programs , 1984, SDE 1.

[23]  David W. Binkley,et al.  Program slicing , 2008, 2008 Frontiers of Software Maintenance.

[24]  Ralf Carbon,et al.  Variability management in small development organizations: experiences and lessons learned from a case study , 2009, SPLC.

[25]  Sergio Segura,et al.  Automated analysis of feature models 20 years later: A literature review , 2010, Inf. Syst..

[26]  Sven Apel,et al.  An Overview of Feature-Oriented Software Development , 2009, J. Object Technol..

[27]  Eric A. Brewer,et al.  ASTEC: a new approach to refactoring C , 2005, ESEC/FSE-13.

[28]  João M. Fernandes,et al.  Towards a catalog of aspect-oriented refactorings , 2005, AOSD '05.

[29]  Andrew C. Myers,et al.  Parameterized types for Java , 1997, POPL '97.

[30]  Wolfgang Schröder-Preikschat,et al.  A quantitative analysis of aspects in the eCos kernel , 2006, EuroSys.

[31]  Oscar Nierstrasz,et al.  Traits: A mechanism for fine-grained reuse , 2006, TOPL.

[32]  Gregor Kiczales,et al.  Discussing aspects of AOP , 2001, CACM.

[33]  Don S. Batory,et al.  Automating Feature-Oriented Refactoring of Legacy Applications , 2007, WRT.

[34]  Wolfgang Schröder-Preikschat,et al.  Dead or Alive: finding zombie features in the Linux kernel , 2009, FOSD '09.

[35]  Charles W. Krueger,et al.  Easing the Transition to Software Mass Customization , 2001, PFE.

[36]  Danilo Beuche,et al.  Variability management with feature models , 2004, Sci. Comput. Program..

[37]  Dirk Muthig,et al.  Generic Implementation of Product Line Components , 2002, NetObjectDays.

[38]  Hans-Arno Jacobsen,et al.  Quantifying aspects in middleware platforms , 2003, AOSD '03.

[39]  Marc Roper,et al.  A Comparative Evaluation of Program Comprehension Measures , 2000 .

[40]  Dewayne E. Perry,et al.  Design of large-scale polylingual systems , 2004, Proceedings. 26th International Conference on Software Engineering.

[41]  Gunter Saake,et al.  On the impact of the optional feature problem: analysis and case studies , 2009, SPLC.

[42]  Olly Gotel,et al.  An analysis of the requirements traceability problem , 1994, Proceedings of IEEE International Conference on Requirements Engineering.

[43]  Klaus Pohl,et al.  Software Product Line Engineering - Foundations, Principles, and Techniques , 2005 .

[44]  Thomas Leich,et al.  Tool support for feature-oriented software development: featureIDE: an Eclipse-based approach , 2005, eclipse '05.

[45]  Michael Poppleton,et al.  Towards Feature-Oriented Specification and Development with Event-B , 2007, REFSQ.

[46]  Paul Clements,et al.  Software architecture in practice , 1999, SEI series in software engineering.

[47]  Don S. Batory,et al.  On the modularity of feature interactions , 2008, GPCE '08.

[48]  Kyo Chul Kang,et al.  Feature-Oriented Domain Analysis (FODA) Feasibility Study , 1990 .

[49]  Gary T. Leavens,et al.  MultiJava: Design rationale, compiler implementation, and applications , 2006, TOPL.

[50]  William G. Griswold,et al.  The structure and value of modularity in software design , 2001, ESEC/FSE-9.

[51]  Krzysztof Czarnecki,et al.  Verifying feature-based model templates against well-formedness OCL constraints , 2006, GPCE '06.

[52]  Christian Wende,et al.  On Controlled Visualisations in Software Product Line Engineering , 2008, SPLC.

[53]  David Notkin,et al.  Error reporting with graduated color , 1992, IEEE Software.

[54]  David Lorge Parnas,et al.  Review of David L. Parnas' "Designing Software for Ease of Extension and Contraction" , 2004 .

[55]  Sven Apel,et al.  Granularity in software product lines , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[56]  H. Bastian Sensation and Perception.—I , 1869, Nature.

[57]  Henry Spencer,et al.  #ifdef Considered Harmful, or Portability Experience with C News , 1992, USENIX Summer.

[58]  Robert J. Hall,et al.  Fundamental Nonmodularity in Electronic Mail , 2004, Automated Software Engineering.

[59]  Thomas Leich,et al.  Tailor-made data management for embedded systems: A case study on Berkeley DB , 2009, Data Knowl. Eng..

[60]  Yuanyuan Song,et al.  Modular software design with crosscutting interfaces , 2006, IEEE Software.

[61]  Uwe Aßmann,et al.  Invasive Software Composition , 2003, Springer Berlin Heidelberg.

[62]  Wuu Yang,et al.  How to merge program texts , 1994, J. Syst. Softw..

[63]  Ilka Philippow,et al.  Enabling Automated Traceability Maintenance by Recognizing Development Activities Applied to Models , 2008, 2008 23rd IEEE/ACM International Conference on Automated Software Engineering.

[64]  Ari Jaaksi,et al.  Developing Mobile Browsers in a Product Line , 2002, IEEE Softw..

[65]  Yvonne Coady,et al.  CViMe: viewing conditionally compiled C/C++ sources through Java , 2006, OOPSLA '06.

[66]  Malte Rosenthal,et al.  Alternative Features in Colored Featherweight Java , 2009 .

[67]  João Araújo,et al.  Early aspects: a model for aspect-oriented requirements engineering , 2002, Proceedings IEEE Joint International Conference on Requirements Engineering.

[68]  Sholom Cohen,et al.  Product Line Practice Workshop Report. , 1998 .

[69]  Michel Dagenais,et al.  C/C++ conditional compilation analysis using symbolic execution , 2000, Proceedings 2000 International Conference on Software Maintenance.

[70]  Edsger W. Dijkstra,et al.  A Discipline of Programming , 1976 .

[71]  Vassily Litvinov Contraint-based polymorphism in Cecil: towards a practical and static type system , 1998, OOPSLA '98.

[72]  Gregor Snelting,et al.  On the inference of configuration structures from source code , 1994, Proceedings of 16th International Conference on Software Engineering.

[73]  William R. Cook,et al.  Safe composition of product lines , 2007, GPCE '07.

[74]  James R. Cordy Eating our own dog food: DSLs for generative and transformational engineering , 2009, GPCE '09.

[75]  Ira D. Baxter,et al.  Preprocessor conditional removal by simple partial evaluation , 2001, Proceedings Eighth Working Conference on Reverse Engineering.

[76]  Martin Leucker,et al.  Modeling and Model Checking Software Product Lines , 2008, FMOODS.

[77]  Christian Wende,et al.  FeatureMapper: mapping features to models , 2008, ICSE Companion '08.

[78]  Martin L. Griss,et al.  Integrating feature modeling with the RSEB , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[79]  S. Kotha Mass Customization: The New Frontier in Business Competition , 1992 .

[80]  A. Nico Habermann,et al.  Modularization and hierarchy in a family of operating systems , 1976, CACM.

[81]  Ted J. Biggerstaff,et al.  The library scaling problem and the limits of concrete component reuse , 1994, Proceedings of 1994 3rd International Conference on Software Reuse.

[82]  Kathi Fisler,et al.  A Case Study in Using ACL 2 for Feature-Oriented Verification , 2004 .

[83]  Kent L. Beck,et al.  Test-driven Development - by example , 2002, The Addison-Wesley signature series.

[84]  Gilad Bracha,et al.  The programming language jigsaw: mixins, modularity and multiple inheritance , 1992 .

[85]  DeLesley Hutchins,et al.  Pure subtype systems : a type theory for extensible software , 2009 .

[86]  Paulo Borba,et al.  Deriving refactorings for aspectJ , 2004, OOPSLA '04.

[87]  Mads Torgersen The expression problem revisited: Four new solutions using generics , 2004 .

[88]  Matthew J. Parkinson,et al.  The java module system: core design and semantic definition , 2007, OOPSLA.

[89]  Holger Giese,et al.  From model transformation to incremental bidirectional model synchronization , 2009, Software & Systems Modeling.

[90]  Kris De Volder,et al.  Programming with Crosscutting Effective Views , 2004, ECOOP.

[91]  Sven Apel,et al.  Refactoring Feature Modules , 2009, ICSR.

[92]  Atsushi Igarashi,et al.  On Inner Classes , 2002, Inf. Comput..

[93]  Sven Apel,et al.  Feature featherweight java: a calculus for feature-oriented programming and stepwise refinement , 2008, GPCE '08.

[94]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[95]  Hassan Gomaa,et al.  Separation of concerns in software product line engineering , 2005, ACM SIGSOFT Softw. Eng. Notes.

[96]  Shan Shan Huang,et al.  Expressive and safe static reflection with MorphJ , 2008, PLDI '08.

[97]  Sven Apel,et al.  When to use features and aspects?: a case study , 2006, GPCE '06.

[98]  Stephan Diehl,et al.  Software Visualization - Visualizing the Structure, Behaviour, and Evolution of Software , 2007 .

[99]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[100]  Oscar Díaz,et al.  Feature Oriented Model Driven Development: A Case Study for Portlets , 2007, 29th International Conference on Software Engineering (ICSE'07).

[101]  Todd D. Millstein,et al.  Statically scoped object adaptation with expanders , 2006, OOPSLA '06.

[102]  Jeffrey G. Gray,et al.  A technique for constructing aspect weavers using a program transformation engine , 2004, AOSD '04.

[103]  Luca Cardelli,et al.  Program fragments, linking, and modularization , 1997, POPL '97.

[104]  Martin P. Robillard,et al.  Concern graphs: finding and describing concerns using structural program dependencies , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[105]  Matthias Felleisen,et al.  Hygienic macro expansion , 1986, LFP '86.

[106]  Charles W. Krueger,et al.  Software reuse , 1992, CSUR.

[107]  Sven Apel,et al.  Die Rolle von Features und Aspekten in der Softwareentwicklung (The Role of Features and Aspects in Software Development) , 2008, it Inf. Technol..

[108]  Roberto Erick Lopez-Herrejon,et al.  Generating product-lines of product-families , 2002, Proceedings 17th IEEE International Conference on Automated Software Engineering,.

[109]  Ole Lehrmann Madsen,et al.  Virtual classes: a powerful mechanism in object-oriented programming , 1989, OOPSLA '89.

[110]  Jörgen Hansson,et al.  Application-tailored database systems: a case of aspects in an embedded database , 2004, Proceedings. International Database Engineering and Applications Symposium, 2004. IDEAS '04..

[111]  Oscar Nierstrasz,et al.  Classbox/J: controlling the scope of change in Java , 2005, OOPSLA '05.

[112]  Matthias Felleisen,et al.  Classes and mixins , 1998, POPL '98.

[113]  Burt M. Leavenworth,et al.  Syntax macros and extended translation , 1966, CACM.

[114]  John D. McGregor,et al.  Testing a Software Product Line , 2001, PSSE.

[115]  Cristina Gacek,et al.  Implementing product line variabilities , 2001, SSR '01.

[116]  Hans-Arno Jacobsen,et al.  Resolving feature convolution in middleware systems , 2004, OOPSLA.

[117]  Donald D. Cowan,et al.  Efficient compilation techniques for large scale feature models , 2008, GPCE '08.

[118]  Gunter Saake,et al.  Type checking annotation-based product lines , 2012, TSEM.

[119]  Ina Schaefer,et al.  Implementing software product lines using traits , 2010, SAC '10.

[120]  Danilo Beuche,et al.  The PURE family of object-oriented operating systems for deeply embedded systems , 1999, Proceedings 2nd IEEE International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC'99) (Cat. No.99-61702).

[121]  Benavides Cuevas,et al.  On the Automated Analysis of Software Product Lines Using Feature Models. A Framework for Developing Automated Tool Support. , 2014 .

[122]  M. F.,et al.  Bibliography , 1985, Experimental Gerontology.

[123]  Lianping Chen,et al.  Variability management in software product lines: a systematic review , 2009, SPLC.

[124]  Jean-Marie Favre Understanding-in-the-large , 1997, Proceedings Fifth International Workshop on Program Comprehension. IWPC'97.

[125]  Elmar Gerhards-Padilla,et al.  Platform-Independent Recognition of Procedures in Binaries Based on Simple Characteristics , 2012, it Inf. Technol..

[126]  Krzysztof Czarnecki,et al.  SAT-based analysis of feature models is easy , 2009, SPLC.

[127]  Charles W. Krueger,et al.  Point - Counterpoint: Being Proactive Pays Off - Eliminating the Adoption , 2002, IEEE Softw..

[128]  Sven Apel,et al.  Visualizing Software Product Line Variabilities in Source Code , 2008, SPLC.

[129]  Paul W. Oman,et al.  Experiences developing and maintaining software in a multi-platform environment , 1997, 1997 Proceedings International Conference on Software Maintenance.

[130]  Pierre-Yves Schobbens,et al.  Generic semantics of feature diagrams , 2007, Comput. Networks.

[131]  Yvonne Coady,et al.  C-CLR: a tool for navigating highly configurable system software , 2007, ACP4IS.

[132]  Shan Shan Huang,et al.  cJ: enhancing java with safe type conditions , 2007, AOSD.

[133]  Arie van Deursen,et al.  Simple crosscutting concerns are not so simple: analysing variability in large-scale idioms-based implementations , 2007, AOSD.

[134]  Klaus Pohl,et al.  Software product line testing , 2006, CACM.

[135]  Matthew Flatt,et al.  Jiazzi: new-age components for old-fasioned Java , 2001, OOPSLA '01.

[136]  Sebastian Günther,et al.  Representing and Composing First-class Features with FeatureJ , 2009 .

[137]  M. Humphrey,et al.  Evaluation of the maintainability of object-oriented software , 1990, IEEE TENCON'90: 1990 IEEE Region 10 Conference on Computer and Communication Systems. Conference Proceedings.

[138]  Gang Chen,et al.  Design Wizards and Visual Programming Environments for GenVoca Generators , 2000, IEEE Trans. Software Eng..

[139]  Árpád Beszédes,et al.  Opening Up The C/C++ Preprocessor Black Box , 2003, SPLST.

[140]  Andrew M. Sutton,et al.  How We Manage Portability and Configuration with the C Preprocessor , 2007, 2007 IEEE International Conference on Software Maintenance.

[141]  Sven Apel,et al.  A Case Study Implementing Features Using AspectJ , 2007, 11th International Software Product Line Conference (SPLC 2007).

[142]  Stan Jarzabek,et al.  XVCL: a mechanism for handling variants in software product lines , 2004, Sci. Comput. Program..

[143]  Thomas Leich,et al.  An orthogonal access modifier model for feature-oriented programming , 2009, FOSD '09.

[144]  Aaron Turon,et al.  Metaprogramming with Traits , 2007, ECOOP.

[145]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[146]  Brian Foote,et al.  Designing Reusable Classes , 2001 .

[147]  Jan Bosch,et al.  A taxonomy of variability realization techniques , 2005, Softw. Pract. Exp..

[148]  Sven Apel,et al.  FEATUREHOUSE: Language-independent, automated software composition , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[149]  Don S. Batory,et al.  Scaling step-wise refinement , 2004, IEEE Transactions on Software Engineering.

[150]  David Coppit,et al.  Spotlight: A Prototype Tool for Software Plans , 2007, 29th International Conference on Software Engineering (ICSE'07).

[151]  Yann-Gaël Guéhéneuc,et al.  Feature Location Using Probabilistic Ranking of Methods Based on Execution Scenarios and Information Retrieval , 2007, IEEE Transactions on Software Engineering.

[152]  Michael D. Ernst,et al.  An Empirical Analysis of C Preprocessor Use , 2002, IEEE Trans. Software Eng..

[153]  Daniel Weise,et al.  Programmable syntax macros , 1993, PLDI '93.

[154]  Niklaus Wirth,et al.  Program development by stepwise refinement , 1971, CACM.

[155]  Sagar Sunkle,et al.  Enabling Feature-Oriented Programming in Ruby , 2009 .

[156]  Carl K. Chang,et al.  Event-Based Traceability for Managing Evolutionary Change , 2003, IEEE Trans. Software Eng..

[157]  Mira Mezini,et al.  Untangling crosscutting models with Caesar , 2005 .

[158]  Reidar Conradi,et al.  Version models for software configuration management , 1998, CSUR.

[159]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[160]  David Coppit,et al.  Software Plans for Separation of Concerns , 2004 .

[161]  Abdul Azim Abdul Ghani,et al.  A Survey on Aspect-Oriented Testing Approaches , 2007, 2007 International Conference on Computational Science and its Applications (ICCSA 2007).

[162]  Benjamin C. Pierce,et al.  Combinators for bi-directional tree transformations: a linguistic approach to the view update problem , 2005, POPL '05.

[163]  Ralph E. Johnson,et al.  Analyzing multiple configurations of a C program , 2005, 21st IEEE International Conference on Software Maintenance (ICSM'05).

[164]  Ted J. Biggerstaff,et al.  A perspective of generative reuse , 1998, Ann. Softw. Eng..

[165]  William R. Cook,et al.  A virtual class calculus , 2006, POPL '06.

[166]  Paul Grünbacher,et al.  Supporting Product Derivation by Adapting and Augmenting Variability Models , 2007, 11th International Software Product Line Conference (SPLC 2007).

[167]  Benjamin C. Pierce,et al.  Types and programming languages: the next generation , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[168]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

[169]  Charles Simonyi,et al.  The Death of Computer Languages, The Birth of Intentional Programming , 1995 .

[170]  Shan Shan Huang,et al.  Statically safe program generation with safegen , 2005, GPCE'05.

[171]  John C. Reynolds User-defined types and procedural data structures as complementary approaches to data abstraction , 1994 .

[172]  Raymie Stata,et al.  Modular reasoning in the presence of subclassing , 1995, OOPSLA.

[173]  Mik Kersten,et al.  Mylar: a degree-of-interest model for IDEs , 2005, AOSD '05.

[174]  Sven Apel,et al.  An analysis of the variability in forty preprocessor-based software product lines , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[175]  Rainer Koschke,et al.  Locating Features in Source Code , 2003, IEEE Trans. Software Eng..

[176]  Mik Kersten,et al.  Using task context to improve programmer productivity , 2006, SIGSOFT '06/FSE-14.

[177]  Cláudio Sant'Anna,et al.  Evolving software product lines with aspects , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[178]  Wolfgang De Meuter,et al.  Can we refactor conditional compilation into aspects? , 2009, AOSD '09.

[179]  G. Kiczales,et al.  Aspect-oriented programming and modular reasoning , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[180]  Yannis Smaragdakis,et al.  Mixin layers: an object-oriented implementation technique for refinements and collaboration-based designs , 2002, TSEM.

[181]  Sebastian Günther,et al.  Feature-oriented programming with Ruby , 2009, FOSD '09.

[182]  Martin P. Robillard,et al.  Separating features in source code: an exploratory study , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[183]  David S. Wile,et al.  Abstract Syntax from Concrete Syntax , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[184]  Iris Groher,et al.  Product Line Implementation using Aspect-Oriented and Model-Driven Software Development , 2007 .

[185]  Sven Apel,et al.  Language-Independent Quantification and Weaving for Feature Composition , 2009, SC@TOOLS.

[186]  R. Rosenthal,et al.  Teachers' Expectancies: Determinants of Pupils' IQ Gains , 1966, Psychological reports.

[187]  Marko Rosenmüller,et al.  Avoiding Variability of Method Signatures in Software Product Lines: A Case Study , 2007 .

[188]  Roberto Erick Lopez-Herrejon,et al.  A Standard Problem for Evaluating Product-Line Methodologies , 2001, GCSE.

[189]  Nicolas Spyratos,et al.  Update semantics of relational views , 1981, TODS.

[190]  Stephen G. Eick,et al.  Seesoft-A Tool For Visualizing Line Oriented Software Statistics , 1992, IEEE Trans. Software Eng..

[191]  Bashar Nuseibeh,et al.  Towards safer composition , 2009, 2009 31st International Conference on Software Engineering - Companion Volume.

[192]  Kris De Volder,et al.  Navigating and querying code without getting lost , 2003, AOSD '03.

[193]  Mira Mezini,et al.  Separation of Concerns with Procedures, Annotations, Advice and Pointcuts , 2005, ECOOP.

[194]  Sven Apel,et al.  Type-Checking Software Product Lines - A Formal Approach , 2008, 2008 23rd IEEE/ACM International Conference on Automated Software Engineering.

[195]  Eduardo Figueiredo,et al.  Early Crosscutting Metrics as Predictors of Software Instability , 2009, TOOLS.

[196]  Bo Nørregaard Jørgensen,et al.  Evolution of Ccollective Object Behavior in Presence of Simultaneous Client-Specific Views , 2003, OOIS.

[197]  Michael Stonebraker,et al.  On rules, procedure, caching and views in data base systems , 1990, SIGMOD '90.

[198]  Marian Vittek Refactoring browser with preprocessor , 2003, Seventh European Conference onSoftware Maintenance and Reengineering, 2003. Proceedings..

[199]  Bjarne Stroustrup,et al.  The Design and Evolution of C , 1994 .

[200]  Audris Mockus,et al.  Using Version Control Data to Evaluate the Impact of Software Tools: A Case Study of the Version Editor , 2002, IEEE Trans. Software Eng..

[201]  Jaejoon Lee,et al.  An Approach for Developing Service Oriented Product Lines , 2008, 2008 12th International Software Product Line Conference.

[202]  Robert Grimm,et al.  On the feasibility of an AOSD approach to Linux kernel extensions , 2008, ACP4IS@AOSD.

[203]  Alfred V. Aho,et al.  Do Crosscutting Concerns Cause Defects? , 2008, IEEE Transactions on Software Engineering.

[204]  Clemens A. Szyperski,et al.  Import is Not Inheritance - Why We Need Both: Modules and Classes , 1992, ECOOP.

[205]  Thomas Leich,et al.  FeatureC++: on the symbiosis of feature-oriented and aspect-oriented programming , 2005, GPCE'05.

[206]  Michael Lawley,et al.  Towards Model Round-Trip Engineering: An Abductive Approach , 2009, ICMT@TOOLS.

[207]  Michal Antkiewicz,et al.  Mapping features to models: a template approach based on superimposed variants , 2005, GPCE'05.

[208]  Stanley M. Sutton,et al.  N degrees of separation: multi-dimensional separation of concerns , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[209]  Don S. Batory,et al.  The design and implementation of hierarchical software systems with reusable components , 1992, TSEM.

[210]  Wolfgang Stolz,et al.  Introducing PLA at Bosch Gasoline Systems: Experiences and Practices , 2004, SPLC.

[211]  Gail C. Murphy,et al.  Explicit programming , 2002, AOSD '02.

[212]  Krzysztof Czarnecki,et al.  Formalizing cardinality-based feature models and their specialization , 2005, Softw. Process. Improv. Pract..

[213]  James H. Andrews,et al.  Process-Algebraic Foundations of Aspect-Oriented Programming , 2001, Reflection.

[214]  Ron Cytron,et al.  Footprint and feature management using aspect-oriented programming techniques , 2002, LCTES/SCOPES '02.

[215]  Tobias Nipkow,et al.  Javalight is type-safe—definitely , 1998, POPL '98.

[216]  Andy Clement,et al.  Aspect-Oriented Programming with AJDT , 2003 .

[217]  Klaus Pohl,et al.  Model Checking of Domain Artifacts in Product Line Engineering , 2009, 2009 IEEE/ACM International Conference on Automated Software Engineering.

[218]  Jonathan Aldrich,et al.  Open Modules: Modular Reasoning About Advice , 2005, ECOOP.

[219]  Oscar Díaz,et al.  Feature refactoring a multi-representation program into a product line , 2006, GPCE '06.

[220]  Sven Apel,et al.  Types and modularity for implicit invocation with implicit announcement , 2010, TSEM.

[221]  Hans-Arno Jacobsen,et al.  Horizontal decomposition of Prevayler , 2005, CASCON.

[222]  Matthias Jarke,et al.  Toward Reference Models of Requirements Traceability , 2001, IEEE Trans. Software Eng..

[223]  Clemens A. Szyperski,et al.  Component software - beyond object-oriented programming , 2002 .

[224]  Mario Latendresse Rewrite systems for symbolic evaluation of C-like preprocessing , 2004, Eighth European Conference on Software Maintenance and Reengineering, 2004. CSMR 2004. Proceedings..

[225]  David McComas,et al.  Verifying architectural design rules of the flight software product line , 2009, SPLC.

[226]  Jia Liu,et al.  Feature oriented refactoring of legacy applications , 2006, ICSE '06.

[227]  Oscar Nierstrasz,et al.  Composing Unit Tests , 2005 .

[228]  David L. Atkins Version Sensitive Editing: Change History as a Programming Tool , 1998, SCM.

[229]  Mira Mezini,et al.  Conquering aspects with Caesar , 2003, AOSD '03.

[230]  Mark Staples,et al.  Experiences adopting software product line development without a product line architecture , 2004, 11th Asia-Pacific Software Engineering Conference.

[231]  Bram Adams,et al.  Aspect mining in the presence of the C preprocessor , 2008, LATE@AOSD.

[232]  J. Favre The CPP paradox , 1995 .

[233]  Philip Wadler,et al.  Featherweight Java: a minimal core calculus for Java and GJ , 2001, TOPL.

[234]  Christian Prehofer,et al.  Feature-Oriented Programming: A Fresh Look at Objects , 1997, ECOOP.

[235]  Scott P. Robertson,et al.  Expert problem solving strategies for program comprehension , 1991, CHI.

[236]  Klaus Ostermann,et al.  Reasoning about aspects with common sense , 2008, AOSD.

[237]  Friedrich Steimann The paradoxical success of aspect-oriented programming , 2006, OOPSLA '06.

[238]  Mark Carpenter,et al.  The New Statistical Analysis of Data , 2000, Technometrics.

[239]  Sven Apel,et al.  Integrating Compositional and Annotative Approaches for Product Line Engineering , 2008 .

[240]  Matthias Felleisen,et al.  A Syntactic Approach to Type Soundness , 1994, Inf. Comput..

[241]  Thomas Leich,et al.  Aspectual Feature Modules , 2008, IEEE Transactions on Software Engineering.

[242]  Eelco Visser,et al.  Program Transformation with Stratego/XT: Rules, Strategies, Tools, and Systems in Stratego/XT 0.9 , 2003, Domain-Specific Program Generation.

[243]  William G. Griswold,et al.  Exploiting the map metaphor in a tool for software evolution , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[244]  Sophia Drossopoulou,et al.  Java Type Soundness Revisited , 2000 .

[245]  Dachuan Yu,et al.  Variance and Generalized Constraints for C# Generics , 2006, ECOOP.

[246]  Sven Apel,et al.  How AspectJ is Used: An Analysis of Eleven AspectJ Programs , 2010, J. Object Technol..

[247]  Thomas Leich,et al.  FeatureIDE: A tool framework for feature-oriented software development , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[248]  Krzysztof Czarnecki,et al.  Generative Programming for Embedded Software: An Industrial Experience Report , 2002, GPCE.

[249]  Thomas Thüm,et al.  Reasoning about edits to feature models , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[250]  Mark Harman,et al.  Automated refactoring of object oriented code into aspects , 2005, 21st IEEE International Conference on Software Maintenance (ICSM'05).

[251]  Niklaus Wirth The Module: A System Structuring Facility in High-Level Programming Languages , 1979, Language Design and Programming Methodology.

[252]  David Lorge Parnas,et al.  On the Design and Development of Program Families , 2001, IEEE Transactions on Software Engineering.

[253]  Sven Apel,et al.  Program refactoring using functional aspects , 2008, GPCE '08.

[254]  Sven Apel,et al.  Guaranteeing Syntactic Correctness for All Product Line Variants: A Language-Independent Approach , 2009, TOOLS.

[255]  Krzysztof Czarnecki,et al.  Feature Diagrams and Logics: There and Back Again , 2007, 11th International Software Product Line Conference (SPLC 2007).

[256]  Juha Taina,et al.  Product family testing: a survey , 2004, SOEN.

[257]  Danilo Beuche,et al.  Running a software product line: standing still is going backwards , 2009, SPLC.

[258]  Yuanyuan Song,et al.  Information hiding interfaces for aspect-oriented design , 2005, ESEC/FSE-13.

[259]  Benjamin C. Pierce,et al.  Relational lenses: a language for updatable views , 2006, PODS '06.

[260]  H. Ossher,et al.  Concern modeling in the concern manipulation environment , 2005, MACS@ICSE.

[261]  Stanley M. Sutton,et al.  Hyper/J™: multi-dimensional separation of concerns for Java™ , 2001, ICSE '02.

[262]  Ramnivas Laddad,et al.  Aspectj in Action: Practical Aspect-Oriented Programming , 2003 .

[263]  Pierre-Yves Schobbens,et al.  Disambiguating the Documentation of Variability in Software Product Lines: A Separation of Concerns, Formalization and Automated Analysis , 2007, 15th IEEE International Requirements Engineering Conference (RE 2007).

[264]  Michael Eisenbarth,et al.  A decade of scoping: a survey , 2009, SPLC.

[265]  Craig Schaffert,et al.  CLU Reference Manual , 1984, Lecture Notes in Computer Science.

[266]  Krzysztof Czarnecki,et al.  Generative programming - methods, tools and applications , 2000 .

[267]  Mario Kolberg,et al.  Feature interaction: a critical review and considered forecast , 2003, Comput. Networks.

[268]  Gilad Bracha,et al.  Modularity meets inheritance , 1992, Proceedings of the 1992 International Conference on Computer Languages.