PRODUCT SUPPORT ANNOUNCEMENT
Some videos and Web Editions may be returning errors on launch. Learn more.
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)
Aspect-Oriented Software DevelopementBack Cover Copy
Using AOSD to streamline complex systems development without sacrificing flexibility or scalability
How AOSD builds on the object-oriented paradigmand 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.
Download the Sample
Chapter related to this title.
I. LANGUAGES AND FOUNDATIONS.
2. Aspect-Oriented Programming Is Quantification and Obliviousness.
3. N Degrees of Separation: Multi-Dimensional Separation of Concerns.
4. Principles and Design Rationale of Composition Filters.
5. AOP: A Historical Perspective (What's in a Name?).
7. Coupling Aspect-Oriented and Adaptive Programming.
8. Untangling Crosscutting Models with Caesar.
9. Trace-Based Aspects.
10. Using Mixin Technology to Improve Modularity.
11. Separating Concerns with First-Class Namespaces.
12. Supporting AOP Using Reflection.
13. Inserting Ilities by Controlling Communications.
14. Using Bytecode Transformation to Integrate New Features.
15. JMangler-A Powerful Back-End for Aspect-Oriented Programming.
16. Aspect-Oriented Software Development with Java Aspect Components.
II. SOFTWARE ENGINEERING.
17. Engineering Aspect-Oriented Systems.
18. Aspect-Orientation in the Software Lifecycle: Fact and Fiction.
19. Generic Aspect-Oriented Design with Theme/UML.
20. Expressing Aspects Using UML Behavioral and Structural Diagrams.
21. Concern Modeling for Aspect-Oriented Software Development.
22. Design Recommendations for Concern Elaboration Tools.
23. An Initial Assessment of Aspect-Oriented Programming.
24. Aspect-Oriented Dependency Management.
25. Developing Software Components with Aspects: Some Issues and Experiences.
26. Smartweaver: A Knowledge-Driven Approach for Aspect Composition.
27. Developing Secure Applications Through Aspect-Oriented Programming.
28. Structuring Operating System Aspects.
29. Aspect-Oriented Programming for Database Systems.
30. Two-Level Aspect Weaving to Support Evolution in Model-Driven Synthesis.
31. Dynamic Aspect-Oriented Infrastructure.
Software is about building computational models of some part of the elements or information flow of the world. For all but the most trivial software systems, conquering the engineering of the system requires (perhaps recursively) dividing the system into chunks that can be (by and large) separately created and managed. The last decade of the twentieth century saw the rise (and perhaps dominance) of the object-oriented perspective on system modularization. Object-orientation focuses on selecting objects as the primary unit of modularity and associating with these objects all the system's behavior. Objects are typically elements of the domain or of the computational process.
Object-orientation is reaching its limits. Many things one cares about in creating a software system (concerns) are not neatly localized to the behavior of specific "things." Building diverse systems requires simultaneously manipulating many concerns. Examples of concerns range from non-functional notions such as security, reliability, and manageability to precise implementation techniques such as concurrency control, caching, and error recovery. Since conventional programming technologies are centered on producing a direct sequence of instructions, they require the programmer to remain cognizant of all such concerns throughout the programming process. The programmer must explicitly intermix the commands to achieve these concerns with the code for the primary application functionality. This produces tangled code and erroneous and difficult-to-maintain systems.
New technologies are emerging to allow richer specifications of programs and better modularization of these specifications. Along with these new technologies, we are also seeing novel software engineering methodologies for using them. One of the most exciting of these new technologies is aspect-oriented software development (AOSD). AOSD programming technologies (aspect-oriented programming, or AOP) provide linguistic mechanisms for separate expression of concerns, along with implementation technologies for weaving these separate concerns into working systems. Aspect-oriented software engineering (AOSE) technologies are emerging for managing the process of developing systems within this new paradigm.
About This Book
This book grew out of our experience with the special issue on aspect-orientation in the October, 2001 Communications of the ACM. Seven times as many papers were submitted to that issue as we could print; those that appeared proved among the most popular in the ACM digital library. Simultaneously, we saw a growing number of increasingly popular workshops on aspect-oriented topics. There was clearly great interest in the computer science community for learning more about aspects. This led to two ideasestablishing an international conference on aspect-oriented software development and creating a book to illustrate to the advanced software development community the diversity of ideas in this space. The conference, organized by the Aspect-Oriented Software Association and co-sponsored by ACM, has recently had its third annual meeting; the proceedings are in the ACM digital library.
We intend this book as a volume for advanced software engineers interested in learning about this new direction in software development. To populate the book, we sent out invitations to selected researchers in the field either to submit a new paper presenting an overview of their work or to nominate an appropriate existing paper for reprinting. This book is the result of selecting from and editing those submissions.
How to Read This Book
We recommend the first chapter, which is an introduction to the ideas of aspect-oriented software development, to all readers. Beyond that, system development rests on a basis of programming languages and models, though actual system development demands all the processes of an engineering activity. The ultimate test of a software technology is the systems whose construction it has supported, though aspects are not sufficiently mature to have an impressive portfolio. Correspondingly, after the introduction, the book is structured in three parts: Part 1, "Languages and Foundations," is primarily descriptions of languages for implementing aspects, with some attention to the place of aspects in the programming language universe. Part 2, "Software Engineering," describes technologies for the aspect-oriented software development process. Finally, Part 3, "Applications," details some of the first application experiences using aspect technology. Each part has an introductory section delimiting the space of aspect technology within the topic and outlining the place of each chapter in that space. Beyond that introduction, the chapters (as befits a contributed book on the state-of-the-art) are fundamentally independent. While the authors make the typical reference to other's works, almost every chapter is self-contained.