Aspect-Oriented Software Development

Description

Aspect-oriented Software Development (AOSD) is receiving considerableattention in the software engineering and programming language communities.Since 1997, there have been several successful workshops on AOSD at theleading software engineering conferences. Many have felt that AOSD may havebeen ahead of its time, but the practicality and promise of this paradigm iscatching up with the theory. This new book offers the definitve look at AOSDfrom the movers and shakers behind this concept. Just as object-orientedprogramming was a radical departure from structured programming, AOSD isa departure from the OO concept. AOSD offers increased flexibility and abetter way to develop complex systems without sacrificing scalability, security,and other important concerns. In this book, readers will learn the state-of-theartbest practices in AOSD, and will be able to help their organizations savetime and money by developing complex software systems more efficiently.

Back Cover

Aspect-Oriented Software DevelopementBack Cover Copy

Coverage includes

• Using AOSD to streamline complex systems development without sacrificing flexibility or scalability

• How AOSD builds on the object-oriented paradigm—and how it's different

• State-of-the-art best practices for the AOSD development process

• Languages and foundations: separating concerns, filter technologies, improving modularity, integrating new features, and more

• Using key AOSD tools, including AspectJ, Hyper/J, JMangler, and Java Aspect Components

• Engineering aspect-oriented systems: UML, concern modeling and elaboration, dependency management, and aspect composition

• Developing more secure applications with AOSD techniques

• Applying aspect-oriented programming to database systems

• Building dynamic aspect-oriented infrastructure

The definitive aspect-oriented software development reference:

Practical solutions for the challenge of software complexity

Today, software engineers must build systems that address an increasingly wide range of technical, business, and performance concerns. Doing so using conventional object-oriented techniques, they often find themselves producing tangled, incorrect, difficult-to-maintain code. Aspect-oriented software development (AOSD) overcomes this problem by enabling them to express concerns separately, and then compose modularized expressions into reliable, effective systems.

In this book, four leaders in AOSD development bring together today's most significant advances. Drawing on contributions from the field's leading researchers, they introduce fundamental AOSD concepts, present new technologies for AOSD engineering and programming, and detail early application experiences with AOSD methods.

Aspect-oriented development has come of age. If you're an experienced software engineer or architect, this foundation reference is all you need to start applying it in real-world systems.

© Copyright Pearson Education. All rights reserved.

Contents

1. Introduction.

Book Organization.

Common Terminology.

Historical Context.

I. LANGUAGES AND FOUNDATIONS.

2. Aspect-Oriented Programming Is Quantification and Obliviousness.

Introduction.

Local and Unitary Statements.

Obliviousness.

Quantification.

Static Quantification.

Dynamic Quantification.

Implementation Issues.

Aspect-Oriented Languages.

Related Work.

Closing Remarks.

Acknowledgments.

References.

3. N Degrees of Separation: Multi-Dimensional Separation of Concerns.

Introduction.

Motivation.

The First Go-Round.

Evolving the SEE: An Environmental Hazard.

The Postmortem.

Breaking the Tyranny.

3.3 - Multi-Dimensional Separation of Concerns.

A Model of Conventional Software.

Multi-Dimensional Decomposition: Hyperslices.

Composing Hyperslices Using Hypermodules.

Using the Model.

Instantiation.

Mapping to Units and Modules.

Representation of Hyperslices.

Support for Composition.

Related Work.

Conclusions and Future Work.

Acknowledgments.

References.

4. Principles and Design Rationale of Composition Filters.

Introduction.

Background and Aims of the Composition Filters Model: Finding the Right Abstractions.

Example: Social Security Services.

An Overview of the Application.

The Software System.

Intra-Object Crosscutting with Composition Filters.

Concern Instance 5 Object 1 Filters.

Evolution Step 1: Protecting Documents.

A Composition Filters Solution.

Message Processing.

Intra-Object Crosscutting.

Inter-Object Crosscutting.

volution Step 2: Adding Workflow Management.

volution Step 3: Adding Logging.

Evaluation.

Implementations of the CF Model.

Inlining Composition Filters.

Conclusion.

References.

5. AOP: A Historical Perspective (What's in a Name?).

A Matter of Style.

Research Trends in the Early '90s.

Formulation of the Problem.

Analysis of the Problem and Specialized Solutions.

Identifying Concerns That Can Be Separated.

Separation Techniques.

The Birth of AOP at PARC.

RG.

AML.

ETCML.

DJ.

Djava.

AspectJ.

Building Communities.

Researchers.

Practitioners.

Looking Back.

The Essence of AOP.

Future Challenges.

Acknowledgments.

References.

6. AspectJ.

AspectJ Goals.

General Purpose.

Direct Support in the Programming Language.

Easy to Learn.

Incremental Adoption.

Easy to Integrate.

Suitable for Real Applications.

The AspectJ Language.

Join Points.

Pointcuts.

Advice.

Inter-Type Declarations.

Aspects.

Further Reading .

AspectJ Tools.

History.

The Compiler.

IDE Support for AspectJ.

Generating Documentation with ajdoc.

Ant Tasks.

Future Directions.

Concluding Remarks.

Acknowledgments.

References.

7. Coupling Aspect-Oriented and Adaptive Programming.

Introduction.

Concern-Shy Programming.

Structure-Shy Programming.

Shyness as a Metaphor for Adaptive Behavior.

How Shyness Relates to AP.

How Shyness Relates to AOP.

Law of Demeter.

Law of Demeter for Concerns.

Reflective Adaptive Programming with DJ.

Implementation Highlights.

Aspectual Adaptive Programming with DAJ.

Strategy Graph Intersection.

Visitor Classes.

Related Work.

Conclusion.

References.

8. Untangling Crosscutting Models with Caesar.

Introduction.

Requirements on Language Support.

Contribution and Structure of the Part.

Join Point Interception.

Lack of Support for Multi-Abstraction Aspects.

Lack of Support for Sophisticated Mapping.

Lack of Support for Reusable Aspect Bindings.

Lack of Support for Aspectual Polymorphism.

The Caesar Model.

Aspect Collaboration Interfaces.

Aspect Implementations.

Aspect Bindings.

Wrapper Recycling.

Most Specific Wrappers.

Pointcuts and Advices.

Weavelets and Deployment.

Virtual Classes and Static Typing.

Evaluation.

Problems Revisited.

Explicit Versus Implicit Aspect Instantiation/Deployment.

Implementation.

Related Work.

Open Classes.

Adaptive Plug and Play Components.

Collaboration-Based Decomposition.

Implementation of Dynamic Deployment.

Summary and Future Work.

References.

9. Trace-Based Aspects.

Remi Douence, Pascal Fradet, and Mario Südholt.

Introduction.

Characteristics of Trace-Based Aspects.

Observable Execution Trace.

Aspect Language.

Weaving.

Expressive Aspects and Equational Reasoning.

Detection and Resolution of Aspect Interactions.

Aspect Interactions.

Support for Conflict Resolution.

Static Weaving of Safety Properties.

Example.

Weaving Phases.

Just-In-Time Weaving.

Conclusion.

References.

10. Using Mixin Technology to Improve Modularity.

Introduction.

Mixin Technology.

Mixins.

Stepwise Refinement.

Mixin Layers.

Fidget Design.

Architecture.

Components.

The Sibling Pattern.

JL's Implicit This Type Parameter.

Using Fidget.

Mixin Programming Support.

Constructor Propagation.

Deep Conformance.

Future Work.

Semantic Checking.

Class Hierarchy Optimization.

Mixins as Types.

Implementing Parametric Polymorphism.

Related Work.

Conclusion.

Acknowledgments.

References.

11. Separating Concerns with First-Class Namespaces.

Introduction.

Piccola.

Piccola Layers.

Generic Wrappers.

Example: Mixin Layer Composition.

Mixin Layers in Piccola.

Software Evolution with .Mixin Layers.

Specifying Compositional Styles with Forms.

Conclusion.

Acknowledgments.

References.

12. Supporting AOP Using Reflection.

What Is Reflection?

Base-Level Versus Meta-Level.

Meta-Objects and Their Protocols.

Meta-Link and Meta-Object Cooperation.

Example of a Reflective Programming Language and its MOP.

AOP Using Reflection.

From Reflection to AOP.

Example of an Application with Multiple Aspects.

Separating Aspects.

Weaving Aspects.

Discussion.

Flexibility.

Performance.

Complexity.

Tooling.

Reuse.

Conclusion.

References.

13. Inserting Ilities by Controlling Communications.

Achieving Ilities by Controlling Communication.

Object Infrastructure Framework.

Injectors.

Annotations.

Pragma.

Applied Ilities.

Reliability.

Quality of Service.

Manageability.

Security.

Related Work.

Conclusion.

Part References.

14. Using Bytecode Transformation to Integrate New Features.

Aspects and Transformation.

An Overview of Bytecode Transformation.

Static Transformation.

Dynamic Transformation.

Programming Transformation.

Selection.

Use in AOSD.

Lessons Learned.

Interface Design.

Safety, Security, and Correctness.

Multiple Namespaces.

Reflection.

Addressing Transformed Functionality.

Debugging Transformed Code.

Conclusion.

References.

15. JMangler-A Powerful Back-End for Aspect-Oriented Programming.

Introduction.

Challenges for Aspect Weaving.

Promises of Load-Time Analysis and Transformation (LAT).

Aspect-Oriented LAT with JMangler.

Generic Interception.

Java's Class Loader Architecture.

Class-Loader Dependent Interception.

JVM-Dependent Interception.

Platform-Dependent Interception.

Portable Generic Interception.

Open Architecture.

Support for Non-Local Transformations.

The BCEL Weaver.

Transformations and Aspects.

Transformers.

Use of Transformers.

Unanticipated Composition of Transformers.

The Transformation Process.

Example.

Creation of Interface Transformers.

Creation of Code Transformers.

Usage Scenarios.

Load-Time Weaving with JMangler.

Run-Time Weaving with JMangler.

Advanced Features.

Related Work.

Conclusions and Future Work.

Acknowledgments.

Appendix 15.A Simple Code Coverage.

Implementation of the CodeCoverTransformer.

Activation.

References.

16. Aspect-Oriented Software Development with Java Aspect Components.

JAC Framework and Programming Model.

Programming Model.

Design Notation.

Aspect Component Classes.

Pointcut Definition.

A First Simple Example.

Extended Design Notation for Distribution.

JAC Architecture for Distribution.

Aspects Deployment and Distribution.

Distributed Application Example.

Implementation and Performance Issues for JAC.

Implementation of JAC.

Performance Measurements.

Related Technologies and Tools.

Aspect-Oriented Languages and Tools.

Comparison with Design Notations for Aspects.

Conclusion.

References.

II. SOFTWARE ENGINEERING.

17. Engineering Aspect-Oriented Systems.

Requirements Engineering.

Specification.

Design.

Implementation.

Evolution.

Aspect Interaction.

Conclusion.

References.

18. Aspect-Orientation in the Software Lifecycle: Fact and Fiction.

Introduction.

Aspects at Implementation Level.

Motivating Example.

AOP: Fact and Fiction.

Aspects at Design Level.

Aspects in UML.

Aspects from the Software Architecture Perspective.

Conclusion.

Appendix.

Acknowledgments.

Part References.

19. Generic Aspect-Oriented Design with Theme/UML.

Introduction.

Motivation.

Crosscutting Themes: The Model.

Specifying Templates.

Specifying Crosscutting Behavior.

Composition Binding Specification.

Composition Output.

Aspects as Themes: Examples.

Library Base Design.

Example 1: Synchronization Aspect.

Example 2: Observer Aspect.

Map to Hyper/J.

Hyper/J Programming Elements.

Observer in Hyper/J.

Map to AspectJ.

AspectJ Programming Elements.

Algorithm for Mapping to AspectJ.

Observer in AspectJ.

Mapping to Programming Models.

Related Work.

Conclusion.

References.

20. Expressing Aspects Using UML Behavioral and Structural Diagrams.

Introduction.

Concepts, Notation, and the Modeling Language.

Aspect-Oriented Programming.

The Unified Modeling Language (UML).

The Process Prescribed by Our Methodology.

AO Modeling Steps.

The Concurrent Bounded Buffer Problem.

Analysis and Design.

Structural Description Using Class Diagrams.

Modeling Crosscutting Concerns (Steps 6-8).

Realizing the Benefits of Our Methodology.

Implicit Weaving.

Loose Coupling.

Extensibility.

Traceability.

CASE Tools Support for Our Methodology.

Automatic Code Generation and Round-Trip Development.

Conclusion.

Acknowledgments.

References.

21. Concern Modeling for Aspect-Oriented Software Development.

Introduction.

What Is a Concern?

A View of Concerns.

Why Do We Need Concern Modeling?

Specification and Analysis of Concerns Across the Development Lifecycle and Artifacts.

Enhancement of Traditional Development Tasks.

Support of AOSD.

Concern Modeling as a First-Class Undertaking.

Requirements for a Concern-Modeling Schema.

Process Considerations.

Cosmos: A Concern-Space Modeling Schema.

A Concern-Model Example.

Related Work.

Traditional (Non-Aspect Oriented) Modeling.

Aspect-Oriented Modeling.

Additional Discussion.

Formalization of the Notion of "Concern".

Nature of the Contribution to AOSD.

Conclusion.

Acknowledgments.

References.

22. Design Recommendations for Concern Elaboration Tools.

The Tools Studied.

AspectBrowser.

AMT.

FEAT.

Study Format.

The Jex Case.

The AMT Case.

The AspectBrowser Case.

Data.

Strategies Used.

Concern Code Identified.

Results.

Tool Design Recommendations.

Concern Characterization.

Study Validity.

Related Work.

Studies About Program Change Tasks.

Feature Location Approaches.

Impact Analysis Approaches.

Conclusion.

Acknowledgments.

References.

23. An Initial Assessment of Aspect-Oriented Programming.

AspectJ.

Experiments.

General Format.

Experiment 1: Ease of Debugging.

Format.

Results.

Experiment 2: Ease of Change.

Insights from Combined Analysis.

Aspect-Core Interface Matters.

Aspects May Alter Task Strategies.

Experimental Critique.

Related Work.

Summary.

Acknowledgments.

Appendix 23A.

References.

24. Aspect-Oriented Dependency Management.

Dependency Management Principles.

Dependencies.

Dependency Rigidity.

Principles.

Indirection as a Generalized Principle: From Pointers to Design Patterns and Beyond.

More Than Pointers.

Object-Oriented Indirection.

Design Patterns and Indirection.

Aspect-Oriented Indirection.

Aspect-Oriented Alternatives to Design Patterns.

Visitor.

Observer.

Extension Object.

Virtual Construction.

Guidelines for Aspect-Oriented Dependency Management.

Object-Oriented Indirection.

Aspect-Oriented Indirection.

Combined Object- and Aspect-Oriented Indirection.

Modeling Benefits from Aspect-Oriented Dependency Management.

References.

25. Developing Software Components with Aspects: Some Issues and Experiences.

Introduction.

Motivation.

Our Approach.

Component Specification and Design with Aspects.

Component Implementation with Aspects.

Using Aspects at Runtime.

Related Work.

Evaluation.

Future Research Directions.

Conclusion.

References.

26. Smartweaver: A Knowledge-Driven Approach for Aspect Composition.

Knowledge-Driven Weaving.

The Smartbooks Documentation Method.

Programming Tasks in Smartbooks.

The Smartbooks Engine.

A Workflow Application Example.

The Aspect-Moderator Framework.

Applying Smartweaver: The Developer's Viewpoint.

Design of the Target Application.

Interaction with the Task Manager.

Defining the Weaving Knowledge: The Designer's Viewpoint.

Documentation Books of Support Technology.

Adding Weaving Information.

Internal Representation of Aspect Requirements.

Related Work.

Conclusion.

References.

III. APPLICATIONS.

27. Developing Secure Applications Through Aspect-Oriented Programming.

Introduction.

The Domain of Application-Level Security.

An Experience Report.

A Personal Information Management System.

An FTP Server.

Toward a Framework of Aspects.

Discussion.

A Positive Experience.

Requirements for AOP Environments.

Related Work.

Conclusion.

Acknowledgments.

References.

28. Structuring Operating System Aspects.

AspectC.

Normal Behavior Prefetching in AspectC.

Pointcut Declarations.

Advice Declarations.

Implementation Comparison.

Conclusion.

References.

29. Aspect-Oriented Programming for Database Systems.

Introduction.

Crosscutting Concerns in Object-Oriented Database Systems.

Crosscutting Concerns at the DBMS Level.

Crosscutting Concerns at the Database Level.

AOP in Object-Oriented Database Systems.

DBMS-Level Aspects.

Database-Level Aspects.

Evaluation of the Aspect-Oriented Approach.

Other Approaches to Modularizing Crosscutting Concerns in Database Systems.

Conclusion.

References.

30. Two-Level Aspect Weaving to Support Evolution in Model-Driven Synthesis.

Model-Integrated Computing and AOSD.

Model-Integrated Computing.

Crosscutting Concerns in Domain Modeling.

Model Weavers.

Example: Model Weaving of Eager-Lazy Evaluation Constraints.

Modeling Bold Stroke Components in GME.

Strategies for Eager/Lazy Evaluation.

Generating Aspect Code from Domain-Specific Models.

Synthesizing Aspects.

Conclusion.

Future Work.

Related Work.

Acknowledgments.

References.

31. Dynamic Aspect-Oriented Infrastructure.

Introduction.

Application Scenario.

Application Awareness Using Aspect Orientation.

Design Alternatives for Dynamic AOP.

Meeting Application-Awareness Requirements with PROSE.

Addressing Application Awareness in PROSE.

PROSE Architecture.

Weaving Aspects in a Community of Nodes.

Aspect Distribution.

Lifecycle of Aspects.

Software Architecture Issues.

Usage Examples of AOP in Application Awareness.

Location-Specific Functionality for Robotics.

Other Examples of Application Awareness.

Conclusion.

Acknowledgments.

References.

Index.

Features

The definitive reference on the emerging and dynamic field of Aspect-Oriented Software Development (AOSD).

° A proven methodology that offers workable, practical solutions to common problems in all areas of software development

° Readers will learn why so many believe that AOSD is an enhanced version of the object-oriented paradigm

° Product launch at OOPSLA in Vancouver, BC (October 2004)

Author

Aspect-Oriented Software DevelopmentAbout the Editors

Robert E. Filman is a senior scientist at the Research Institute for Advanced Computer Science at NASA Ames Research Center, working on frameworks for distributed applications. He has worked and published in the areas of software engineering, distributed computing, network security, programming languages, artificial intelligence, algorithms, and human-machine interface. He received his Ph.D. in Computer Science in 1979 from Stanford University.

Tzilla Elrad is a research professor in the Department of Computer Science at Illinois Institute of Technology, where she heads the Concurrent Software Systems research group. She received her B.S. in mathematics and physics from the Hebrew University and her M.S. and Ph.D. in Computer Science from Syracuse University, NY and the Technion, Israel, respectively. Her research interests include concurrent programming languages design, adaptive software systems development, and formal reasoning.

Siobhán Clarke is a lecturer in the Department of Computer Science at Trinity College, Dublin. Her research interests include aspect-oriented software development, context-aware computing and programming models for mobile, sentient, context-aware systems. She received her B.S. and Ph.D. degrees from Dublin City University. Prior to her career in research, she worked as a software engineer with IBM for 11 years.

Mehmet Aks¸it holds an M.S. from the Eindhoven University of Technology and a Ph.D. from the University of Twente. He is a professor in the Department of Computer Science, University of Twente, and he is also affiliated with the Centre for Telematics and Information Technology. He (and his group) have developed the composition filters aspect-oriented programming technique, synthesis-based architecture/software design, and techniques to synthesize architectures from solution domains for creating stable software systems, have applied fuzzy-logic to software design, and have created design formalisms such as Design Algebra for balancing various quality factors at different stages of software development.

© Copyright Pearson Education. All rights reserved.