Design dimensions of aspect -oriented systems

Aspect-oriented software development is a promising approach that addresses the problem of modularizing crosscutting concerns – concerns whose implementation cannot be modularized due to the set of abstractions provided by the underlying programming language as well as due to the set of decomposition criteria applied to the underlying problem. Thereto, aspect-oriented systems provide additional abstractions in order to increase the modularity of software systems and consequently to increase the system’s readability, understandability, maintainability and reusability. Nowadays, there are already a number of so-called aspect-oriented systems available that supply a set of new constructs to address the given problem. However, it is not clear what the criteria for a system are in order to be called aspect-oriented and what commonalities and differences exist among different aspect-oriented systems. This also implies that for a given crosscutting concern it cannot be determined on an abstract level what system is able to modularize such a concern in an appropriate way. This thesis describes the characteristics of aspect-oriented systems by so-called design dimensions – orthogonal, conceptual views on the core ingredients of aspect-oriented systems that determine the underlying implementation. It is shown that by means of such abstract design dimensions it is possible to estimate the appropriateness of a system with respect to modularize a given crosscutting concern.

[1]  Gregor Kiczales,et al.  Design pattern implementation in Java and aspectJ , 2002, OOPSLA '02.

[2]  Alan Snyder,et al.  Encapsulation and inheritance in object-oriented programming languages , 1986, OOPLSA '86.

[3]  Stefan Hanenberg,et al.  Roles From an Aspect-Oriented Perspective , 2005 .

[4]  David H. Lorenz,et al.  Aspect Instances and their Interactions , 2003 .

[5]  Stefan Hanenberg,et al.  Modularizing Security Related Concerns in Enterprise Applications - A Case Study with J2EE and AspectJ , 2005, NODe/GSEM.

[6]  Henk Barendregt,et al.  The Lambda Calculus: Its Syntax and Semantics , 1985 .

[7]  Ralph E. Johnson,et al.  Wrappers to the Rescue , 1998, ECOOP.

[8]  Laurence Duchien,et al.  JAC: A Flexible Solution for Aspect-Oriented Programming in Java , 2001, Reflection.

[9]  Stefan Hanenberg,et al.  Concerning AOP and Inheritance , 2001 .

[10]  Bashar Nuseibeh,et al.  Viewpoints: A Framework for Integrating Multiple Perspectives in System Development , 1992, Int. J. Softw. Eng. Knowl. Eng..

[11]  Jörg Kienzle,et al.  AOP: Does It Make Sense? The Case of Concurrency and Failures , 2002, ECOOP.

[12]  K. Volder.  Type Oriented Logic Meta Programming for Java , 1998 .

[13]  Setrag Khoshafian,et al.  Object identity , 1986, OOPLSA '86.

[14]  Stefan Hanenberg,et al.  Eine Taxonomie für aspektorientierte Systeme , 2005, Software Engineering.

[15]  Howard I. Cannon.  Flavors : A non-hierarchical approach to object-oriented programming , 2007 .

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

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

[18]  Martin E. Nordberg.  Aspect-Oriented Dependency Inversion , 2001 .

[19]  Jeffrey D. Ullman,et al.  Introduction to Automata Theory, Languages and Computation , 1979 .

[20]  Mira Mezini,et al.  Aspect-oriented programming and modular reasoning , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

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

[22]  Leon Sterling,et al.  The Art of Prolog - Advanced Programming Techniques , 1986 .

[23]  Mira Mezini,et al.  On aspectualizing component models , 2003, Softw. Pract. Exp..

[24]  Günter Kniesel,et al.  JMangler – A Powerful Back-End for Aspect-Oriented Programming , 2003 .

[25]  Don S. Batory,et al.  A tutorial on feature oriented programming and product-lines , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[26]  Peter Wegner,et al.  Dimensions of object-based language design , 1987, OOPSLA '87.

[27]  Roel Wuyts,et al.  A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation , 2001 .

[28]  Robert Hirschfeld,et al.  AspectS - Aspect-Oriented Programming with Squeak , 2002, NetObjectDays.

[29]  Stefan Hanenberg,et al.  AspectJ Idioms for Aspect-Oriented Software Construction , 2003, EuroPLoP.

[30]  Tom Mens,et al.  Towards a taxonomy of software change , 2005, J. Softw. Maintenance Res. Pract..

[31]  Ralph E. Johnson,et al.  A type system for Smalltalk , 1989, POPL '90.

[32]  Elke Pulvermüller,et al.  Aspect Composition Applying the Design by Contract Principle , 2000, GCSE.

[33]  Siobhán Clarke,et al.  Aspect-oriented analysis and design - the theme approach , 2005, Addison Wesley object technology series.

[34]  Connecting Aspects in AspectJ : Strategies vs . Patterns , 2002 .

[35]  Jens Palsberg,et al.  The essence of the Visitor pattern , 1998, Proceedings. The Twenty-Second Annual International Computer Software and Applications Conference (Compsac '98) (Cat. No.98CB 36241).

[36]  Stefan Hanenberg,et al.  An Object Model for General-Purpose Aspect Languages , 2001, GCSE.

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

[38]  Harold Ossher,et al.  Using multidimensional separation of concerns to (re)shape evolving software , 2001, CACM.

[39]  Hidehiko Masuhara,et al.  A Compilation and Optimization Model for Aspect-Oriented Programs , 2003, CC.

[40]  E. F. CODD,et al.  A relational model of data for large shared data banks , 1970, CACM.

[41]  Gerald Jay Sussman,et al.  The Art of the Interpreter or, The Modularity Complex (Parts Zero, One, and Two) , 1978 .

[42]  David J. DeWitt,et al.  The Object-Oriented Database System Manifesto , 1994, Building an Object-Oriented Database System, The Story of O2.

[43]  Michael Eichberg,et al.  Pointcuts as Functional Queries , 2004, APLAS.

[44]  Brian Foote,et al.  Reflective facilities in Smalltalk-80 , 1989, OOPSLA 1989.

[45]  M. Cibrán,et al.  Aspect-Oriented Programming for Connecting Business Rules , 2003 .

[46]  Guy L. Steele,et al.  Common LISP: the language, 2nd Edition , 1990 .

[47]  Kris De Volder.  Aspect-Oriented Logic Meta Programming , 1998, ECOOP Workshops.

[48]  Lidia Fuentes,et al.  Separation of coordination in a dynamic aspect oriented framework , 2002, AOSD '02.

[49]  Satoshi Matsuoka,et al.  Analysis of inheritance anomaly in object-oriented concurrent programming languages , 1993 .

[50]  Arthur J. Riel,et al.  Object-Oriented Design Heuristics , 1996 .

[51]  Shigeru Chiba,et al.  A Selective, Just-in-Time Aspect Weaver , 2003, GPCE.

[52]  Antero Taivalsaari,et al.  On the notion of inheritance , 1996, CSUR.

[53]  Mark Grand,et al.  Patterns in Java, Volume 1, A Catalog of Reusable Design Patterns Illustrated with UML , 1998 .

[54]  Kim B. Bruce.  Foundations of object-oriented languages - types and semantics , 2002 .

[55]  Gustavo Alonso,et al.  Just-in-time aspects: efficient dynamic weaving for Java , 2003, AOSD '03.

[56]  Aniruddha S. Gokhale,et al.  An Approach for Supporting Aspect-Oriented Domain Modeling , 2003, GPCE.

[57]  DianeC . P. Smith,et al.  Database Abstractions: Aggregation and Generalization , 1989 .

[58]  Uwe Zdun,et al.  Pattern language for the design of aspect languages and aspect composition frameworks , 2004, IEE Proc. Softw..

[59]  Hidehiko Masuhara,et al.  Dataflow Pointcut in Aspect-Oriented Programming , 2003, APLAS.

[60]  Michael Schrefl,et al.  Extending object-oriented systems with roles , 1996, TOIS.

[61]  Gustaf Neumann,et al.  Enhancing object-based system composition through per-object mixins , 1999, Proceedings Sixth Asia Pacific Software Engineering Conference (ASPEC'99) (Cat. No.PR00509).

[62]  Stefan Hanenberg,et al.  Aspect Weaving : Using the Base Language ' s Introspective Facilities to Determine Join Points , 2003 .

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

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

[65]  Stefan Hanenberg,et al.  Morphing aspects: incompletely woven aspects and continuous weaving , 2004, AOSD '04.

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

[67]  Karl Lieberherr,et al.  Adaptive Object-Oriented Software: The Demeter Method with Propagation Patterns , 1995 .

[68]  Roles Conceptual Abstraction Theory Practical Language Issues , 1996 .

[69]  Gunter Kniesel,et al.  Objects don't migrate! Perspectives on Objects with Roles , 1996 .

[70]  Awais Rashid,et al.  Weaving aspects in a persistent environment , 2002, SIGP.

[71]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[72]  Stefan Hanenberg,et al.  Refactoring of Aspect-Oriented Software , 2003 .

[73]  Shigeru Chiba,et al.  Load-Time Structural Reflection in Java , 2000, ECOOP.

[74]  Stefan Hanenberg,et al.  Using and Reusing Aspects in AspectJ , 2001 .

[75]  Günter Kniesel,et al.  Dynamic object-based inheritance with subtyping , 2000 .

[76]  Tzilla Elrad,et al.  Designing an aspect-oriented framework in an object-oriented environment , 2000, CSUR.

[77]  Gary T. Leavens,et al.  Obliviousness, Modular Reasoning, and the Behavioral Subtyping Analogy , 2003 .

[78]  Andreas Ludwig,et al.  Aspect Weaving with Graph Rewriting , 1999, GCSE.

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

[80]  Henry Lieberman,et al.  Using prototypical objects to implement shared behavior in object-oriented systems , 1986, OOPLSA '86.

[81]  Uwe Zdun,et al.  Language support for dynamic and evolving software architectures , 2002 .

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

[83]  Zhao Jianjun,et al.  Refactoring Aspect - Oriented Programs , 2004 .

[84]  Philip Wadler,et al.  Featherweight Java: a minimal core calculus for Java and GJ , 1999, OOPSLA '99.

[85]  Urs Hölzle,et al.  Binary Component Adaptation , 1997, ECOOP.

[86]  Stefan Hanenberg,et al.  Evolvable Pattern Implementations Need Generic Aspects , 2004, RAM-SE.

[87]  Duane Szafron,et al.  Multi-Dispatch in the Java Virtual Machine: Design and Implementation , 2001, COOTS.

[88]  Andreas Heuer,et al.  Principles of Object-Oriented Query Languages , 1991, BTW.

[89]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

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

[91]  Barbara Pernici.  Objects with roles , 1990 .

[92]  Shigeru Chiba,et al.  A metaobject protocol for C++ , 1995, OOPSLA.

[93]  Harold Ossher,et al.  Specifying Subject-Oriented Composition , 1996, Theory Pract. Object Syst..

[94]  Yuanfang Cai,et al.  Non-modularity in aspect-oriented languages: integration as a crosscutting concern for AspectJ , 2002, AOSD '02.

[95]  Jonathan Aldrich.  Open Modules: Reconciling Extensibility and Information Hiding , 2004 .

[96]  Tzilla Elrad,et al.  A Two-Dimensional Composition Framework to Support Software Adaptability and Reuse , 2000, ICSR.

[97]  Wolfgang Pree,et al.  Design Patterns for Object-Oriented Software Development , 1994, Proceedings of the (19th) International Conference on Software Engineering.

[98]  John Maloney,et al.  Back to the Future The Story of Squeak, A Practical Smalltalk Written in Itself , 1997 .

[99]  William G. Griswold,et al.  Semantics-Based Crosscutting in AspectJTM , 2000 .

[100]  Martin Odersky,et al.  Making the future safe for the past: adding genericity to the Java programming language , 1998, OOPSLA '98.

[101]  Pierre-Jacques Courtois,et al.  On time and space decomposition of complex structures , 1985, CACM.

[102]  Stefan Hanenberg,et al.  A Proposal For Classifying Tangled Code , 2002 .

[103]  Christopher Alexander,et al.  The Timeless Way of Building , 1979 .

[104]  Michael Philippsen,et al.  Two Controlled Experiments Assessing the Usefulness of Design Pattern Documentation in Program Maintenance , 2002, IEEE Trans. Software Eng..

[105]  T. Kuhn,et al.  The Structure of Scientific Revolutions. , 1964 .

[106]  Evolving an OS Kernel using Temporal Logic and Aspect-Oriented Programming , 2003 .

[107]  Mitchell Wand.  A Semantics for Advice and Dynamic Join Points in Aspect-Oriented Programming , 2001, SAIG.

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

[109]  Luca Cardelli,et al.  On understanding types, data abstraction, and polymorphism , 1985, CSUR.

[110]  Charles E. McDowell,et al.  Unloading Java classes that contain static fields , 1998, SIGP.

[111]  Stefan Hanenberg,et al.  Visualizing Join Point Selections Using Interaction-Based vs. State-Based Notations Exemplified With Help of Business Rules , 2005, EMISA.

[112]  Kim Mens,et al.  Building Composable Aspect-Specific Languages with Logic Metaprogramming , 2002, GPCE.

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

[114]  Akinori Yonezawa,et al.  Abstracting Object Interactions Using Composition Filters , 1993, ECOOP Workshop.

[115]  Ralf Lämmel.  Adding superimposition to a language semantics , 2003 .

[116]  Hridesh Rajan,et al.  Need for Instance Level Aspect Language with Rich Pointcut Language , 2003 .

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

[118]  Michael Haupt,et al.  The Convergence of AOP and Active Databases: Towards Reactive Middleware , 2003, GPCE.

[119]  Gregor Kiczales,et al.  Using aspectC to improve the modularity of path-specific customization in operating system code , 2001, ESEC/FSE-9.

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

[121]  Bent Bruun Kristensen.  Object-Oriented Modelling with Roles , 1995, OOIS.

[122]  Gary T. Leavens,et al.  MultiJava: modular open classes and symmetric multiple dispatch for Java , 2000, OOPSLA '00.

[123]  Dirk Riehle,et al.  Understanding and Using Patterns in Software Development , 1996, Theory Pract. Object Syst..

[124]  Pattie Maes,et al.  Concepts and experiments in computational reflection , 1987, OOPSLA '87.

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

[126]  Robert Hirschfeld,et al.  Advice Activation in AspectS , 2002 .

[127]  Robert J. Walker,et al.  Implementing protocols via declarative event patterns , 2004, SIGSOFT '04/FSE-12.

[128]  Stanley B. Zdonik,et al.  Inheritance as an Incremental Modification Mechanism or What Like Is and Isn't Like , 1988, ECOOP.