Aspectual Feature Modules

Two programming paradigms are gaining attention in the overlapping fields of software product lines (SPLs) and incremental software development (ISD). Feature-oriented programming (FOP) aims at large-scale compositional programming and feature modularity in SPLs using ISD. Aspect-oriented programming (AOP) focuses on the modularization of crosscutting concerns in complex software. Although feature modules, the main abstraction mechanisms of FOP, perform well in implementing large-scale software building blocks, they are incapable of modularizing certain kinds of crosscutting concerns. This weakness is exactly the strength of aspects, the main abstraction mechanisms of AOP. We contribute a systematic evaluation and comparison of FOP and AOP. It reveals that aspects and feature modules are complementary techniques. Consequently, we propose the symbiosis of FOP and AOP and aspectual feature modules (AFMs), a programming technique that integrates feature modules and aspects. We provide a set of tools that support implementing AFMs on top of Java and C++. We apply AFMs to a nontrivial case study demonstrating their practical applicability and to justify our design choices.

[1]  Sven Apel,et al.  Self-Organization in Overlay Networks , 2005, CAiSE Workshops.

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

[3]  Sven Apel,et al.  An Algebra for Feature-Oriented Software Development , 2007 .

[4]  Mira Mezini,et al.  Programming with Aspectual Components , 1999 .

[5]  David Notkin,et al.  Using C++ Templates to Implement Role-Based Designs , 1996, ISOTAS.

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

[7]  Friedrich Steimann,et al.  On the representation of roles in object-oriented and conceptual modelling , 2000, Data Knowl. Eng..

[8]  Mira Mezini,et al.  Expressive Pointcuts for Increased Modularity , 2005, ECOOP.

[9]  Thomas Leich,et al.  Aspect Refinement Ð Unifying AOP and Stepwise Refinement , 2007, J. Object Technol..

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

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

[12]  Friedrich Steimann,et al.  Domain models are aspect free , 2005, MoDELS'05.

[13]  Václav Rajlich,et al.  Changing the paradigm of software engineering , 2006, CACM.

[14]  K.J. Lieberherr,et al.  Controlling the complexity of software designs , 2004, Proceedings. 26th International Conference on Software Engineering.

[15]  Carlos José Pereira de Lucena,et al.  Refactoring product lines , 2006, GPCE '06.

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

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

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

[19]  Calvin Lin,et al.  Using mixins to build flexible widgets , 2002, AOSD '02.

[20]  Awais Rashid,et al.  Towards a Generic Model for AOP (GEMA) , 2003 .

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

[22]  Eric Eide,et al.  A comparison of Jiazzi and AspectJ for feature-wise decomposition , 2004 .

[23]  Erik Ernst,et al.  Higher-Order Hierarchies , 2003, ECOOP.

[24]  William R. Cook,et al.  A denotational semantics of inheritance , 1989 .

[25]  Wouter Joosen,et al.  Dynamic and selective combination of extensions in component-based applications , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[26]  Jan Bosch,et al.  Superimposition: a component adaptation technique , 1999, Inf. Softw. Technol..

[27]  Wolfgang Schröder-Preikschat,et al.  Lean and Efficient System Software Product Lines: Where Aspects Beat Objects , 2006, LNCS Trans. Aspect Oriented Softw. Dev..

[28]  Daniel P. Friedman,et al.  Aspect-Oriented Programming is Quantification and Obliviousness , 2000 .

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

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

[31]  Ivar Jacobson,et al.  The Unified Modeling Language User Guide , 1998, J. Database Manag..

[32]  Ruzanna Chitchyan,et al.  Semantics-based composition for aspect-oriented requirements engineering , 2007, AOSD.

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

[34]  Eric Wohlstadter,et al.  Doxpects: aspects supporting XML transformation interfaces , 2006, AOSD '06.

[35]  Mira Mezini,et al.  An Overview of CaesarJ , 2006, LNCS Trans. Aspect Oriented Softw. Dev..

[36]  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..

[37]  Don Batory,et al.  From Crosscutting Concerns to Product Lines : A Function Composition Approach , 2006 .

[38]  Oscar Díaz,et al.  Generative metaprogramming , 2007, GPCE '07.

[39]  Awais Rashid,et al.  Framed Aspects: Supporting Variability and Configurability for AOP , 2004, ICSR.

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

[41]  Gregor Kiczales,et al.  Aspect-oriented programming , 2001, ESEC/FSE-9.

[42]  Sven Apel,et al.  Towards the Development of Ubiquitous Middleware Product Lines , 2004, SEM.

[43]  Roberto Erick Lopez-Herrejon,et al.  A disciplined approach to aspect composition , 2006, PEPM '06.

[44]  Martin Odersky,et al.  Scalable component abstractions , 2005, OOPSLA '05.

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

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

[47]  Don S. Batory,et al.  Creating reference architectures: an example from avionics , 1995, SSR '95.

[48]  Sven Apel,et al.  Biology-Inspired Optimizations of Peer-to-Peer Overlay Networks , 2005, Prax. Inf.verarb. Kommun..

[49]  Gregor Kiczales,et al.  A semantics for advice and dynamic join points in aspect-oriented programming , 2001, TOPL.

[50]  Stefan Hanenberg,et al.  Roles and Aspects: Similarities, Differences, and Synergetic Potential , 2002, OOIS.

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

[52]  Jacques Klein,et al.  Semantic-based weaving of scenarios , 2006, AOSD.

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

[54]  Gregor Kiczales,et al.  Back to the future: a retroactive study of aspect evolution in operating system code , 2003, AOSD '03.

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

[56]  Mira Mezini,et al.  Integrating independent components with on-demand remodularization , 2002, OOPSLA '02.

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

[58]  Diomidis Spinellis,et al.  A survey of peer-to-peer content distribution technologies , 2004, CSUR.

[59]  Hidehiko Masuhara,et al.  Modeling Crosscutting in Aspect-Oriented Mechanisms , 2003, ECOOP.

[60]  Xin Qi,et al.  J&: nested intersection for scalable software composition , 2006, OOPSLA '06.

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

[62]  Harold Ossher,et al.  Combination of Inheritance Hierarchies , 1992, OOPSLA.

[63]  Gunter Saake,et al.  Piggyback Meta-Data Propagation in Distributed Hash Tables , 2005, WEBIST.

[64]  Jia Liu,et al.  Refinements and multi-dimensional separation of concerns , 2003, ESEC/FSE-11.

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

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

[67]  Wolfgang De Meuter,et al.  Efficient Layer Activation for Switching Context-Dependent Behavior , 2006, JMLC.

[68]  BatoryDon,et al.  Creating reference architectures , 1995 .

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

[70]  Oscar Díaz,et al.  On Refining XML Artifacts , 2007, ICWE.

[71]  Don Batory,et al.  A programming language for writing domain-specific software system generators , 1996 .

[72]  Klaus Ostermann,et al.  Dynamically Composable Collaborations with Delegation Layers , 2002, ECOOP.

[73]  David Walker,et al.  Harmless advice , 2006, POPL '06.

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

[75]  Kathryn S. McKinley,et al.  Composing high-performance memory allocators , 2001, PLDI '01.

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

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

[78]  Harold Ossher,et al.  Asymmetrically vs. Symmetrically Organized Paradigms for Software Composition , 2002 .

[79]  Calvin Lin,et al.  Comparing frameworks and layered refinement , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

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

[81]  Shmuel Katz,et al.  Superimpositions and Aspect-oriented Programming , 2003, Comput. J..

[82]  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).

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

[84]  Thomas Leich,et al.  Using Step-Wise Refinement to Build a Flexible Lightweight Storage Manager , 2005, ADBIS.

[85]  Eelco Visser,et al.  Concrete syntax for objects: domain-specific language embedding and assimilation without restrictions , 2004, OOPSLA '04.

[86]  Elke Pulvermüller,et al.  Implementing collaboration-based designs using aspect-oriented programming , 2000, Proceedings. 34th International Conference on Technology of Object-Oriented Languages and Systems - TOOLS 34.

[87]  R. T. Alexander.  The real costs of aspect-oriented programming , 2003 .

[88]  Martin L. Griss.  Implementing Product-line features by composing aspects , 2000, SPLC.

[89]  Siobhán Clarke,et al.  Subject-oriented design: towards improved alignment of requirements, design, and code , 1999, OOPSLA '99.

[90]  Sooyong Park,et al.  Combining feature-oriented analysis and aspect-oriented programming for product line asset development , 2006, 10th International Software Product Line Conference (SPLC'06).

[91]  Olaf Spinczyk,et al.  AspectC++ – An AOP Extension for C++ , 2005 .

[92]  Paul Clements,et al.  Software product lines - practices and patterns , 2001, SEI series in software engineering.

[93]  Elizabeth A. Kendall,et al.  Role model designs and implementations with aspect-oriented programming , 1999, OOPSLA '99.

[94]  David Notkin,et al.  Using role components in implement collaboration-based designs , 1996, OOPSLA '96.

[95]  Sven Apel,et al.  Measuring and Characterizing Crosscutting in Aspect-Based Programs: Basic Metrics and Case Studies , 2007, FASE.

[96]  Don S. Batory,et al.  P2: A Lightweight DBMS Generator , 1997, Journal of Intelligent Information Systems.

[97]  Torben Amtoft,et al.  Faithful Translations between Polyvariant Flows and Polymorphic Types , 2000, ESOP.

[98]  Erick Lopez Herrejon.  Understanding feature modularity , 2006 .

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

[100]  Oscar Nierstrasz,et al.  A calculus for reasoning about software composition , 2005, Theor. Comput. Sci..

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

[102]  Stephan Herrmann,et al.  Object Teams: Improving Modularity for Crosscutting Collaborations , 2002, NetObjectDays.

[103]  Klemens Böhm,et al.  Free riding-aware forwarding in Content-Addressable Networks , 2007, The VLDB Journal.

[104]  Don S. Batory,et al.  Achieving extensibility through product-lines and domain-specific languages: a case study , 2000, TSEM.

[105]  Thomas Leich,et al.  Aspectual mixin layers: aspects and features in concert , 2006, ICSE '06.

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

[107]  Tzilla Elrad,et al.  Aspect-oriented programming: Introduction , 2001, CACM.

[108]  Sven Apel,et al.  On the Structure of Crosscutting Concerns : Using Aspects or Collaborations ? , 2006 .

[109]  Karl J. Lieberherr,et al.  Aspectual Collaborations: Combining Modules and Aspects , 2003, Comput. J..

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

[111]  Glenford J. Myers,et al.  Structured Design , 1999, IBM Syst. J..

[112]  Eric Bodden,et al.  Avoiding Infinite Recursion with Stratified Aspects , 2006, NODe/GSEM.

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

[114]  Andrew Clement,et al.  Large-scale AOSD for middleware , 2004, AOSD '04.

[115]  Wilson C. Hsieh,et al.  Aspect-oriented programming with Jiazzi , 2003, AOSD '03.

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

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

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

[119]  Gordon S. Blair,et al.  On the Separation of Concerns in Program Families , 2004 .

[120]  Oege de Moor,et al.  Adding open modules to AspectJ , 2006, AOSD.

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