Virtual Separation of Concerns: Toward Preprocessors 2.0
暂无分享,去创建一个
[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.