Aspect-Oriented Analysis and Design
Aspect-oriented software development (AOSD) is emerging as a proven approach for allowing the separate expression of multiple concerns along with technologies for knitting together these separate expressions into coherent systems. Thanks to its great promise as an approach to simplifying the development of complex systems, many expert observers view AOSD as a worthwhile successor to the prevalent object-oriented paradigm.
In this new book, two AOSD experts apply proven theory to the practical realm of real-world development. They introduce aspects, help the reader identify them, and provide guidance on successful implementation. The result is an applicable and easy-to-digest methodology for simplifying and optimizing the development of software systems, particularly surrounding transaction handling, tracing, database compatibility, performance management, and exception handling.
Aspect-Oriented Analysis and Design: The Theme Approach will be particularly helpful for developers who are trying to answer the common questions of "What is an aspect?" and "Which aspects should I be coding?" Readers will come away with a starting point for thinking about aspects and accounting for them in requirements and design.
Meanwhile, seasoned AO practitioners will learn more about identifying aspect functionality in requirements documentation and how to plan for aspect-design and implementation. The authors' groundbreaking theme approach to AOSD offers both a flexible way to identify aspect functionality and a UML-based design modeling language that can describe aspects independently of programming language.
In short, practitioners and early adopters of AO alike will appreciate this book's practical information on how to make the significant shift to AOSD.
Review By: Harry L. Kirkpatrick
12/02/2005"Aspect-Oriented Analysis and Design" provides a high-level introduction to aspect-oriented programming. It offers a useful approach for identifying aspects in requirements and for designing them in an aspect-oriented way, using UML with a small number of extensions.
In software engineering, the programming paradigm of aspect-oriented programming (AOP)—also called aspect-oriented software development (AOSD)—attempts to aid programmers in the separation of concerns (SoC), or the breaking down of a program into distinct parts that overlap in functionality as little as possible. A concern is any piece of interest or focus in a program. Typically, concerns are synonymous with features or behaviors. In particular, AOP focuses on the modularization and encapsulation of cross-cutting concerns.
All programming paradigms aid developers in the process of SoC. For example, Object-oriented programming languages such as the Java programming language separate concerns into classes and methods. Procedural programming languages such as C and Pascal separate concerns into procedures. Aspect-oriented programming languages divvy concerns into aspects.
In "Aspect-Oriented Analysis and Design," the authors describe the Theme approach for identifying aspects in requirements and modeling them at design. A major strength of the Theme approach is that it allows you to identify and model aspects regardless of the aspect-oriented programming language. Their intention in developing the Theme approach was to enable it to withstand aspect shifts by keeping it separate from any particular programming language and by offering a general-purpose way to identify and describe aspects, regardless of their definition at the code level.
In forming the Theme approach, the authors kept in mind the real goals of the programmer: to understand the problem space (the requirements) and design appropriately. Their objective is to create an approach that allows the developer to map requirements and design to code. Theme/Doc helps you find the aspects in your requirements, while Theme/UML helps you design them. Together, they form the Theme approach.
In addition to talking about the Theme approach and how to apply it, they also describe the different "worlds" of aspect-orientation and how the Theme approach fits into them. You will come away from reading this book not only with tools for analysis and design, but also with an understanding of the general field of aspect-orientation as it stands today.
"Aspect-Oriented Analysis and Design" is written for practitioners and early adopters of aspect-orientation, and it will be helpful for those trying to answer the common questions, like "What is an aspect?" and "Which aspects should I be coding?" The book gives a starting point for thinking about aspects and accounting for them in your requirements and design. It assumes that you are familiar with the object-oriented paradigm and are comfortable with the UML notation.
The book follows the basic structure of introduction and motivation, overview and illustration of the approach, guidance on mapping your designs to some AOP languages, and examples of its application.
The book is packed with figures, examples, and case studies that aid in the learning process. Some parts of the book may be of more interest than others, depending on your perspective. If you're not even sure what an aspect is, the authors cover the basic concepts and walk you through finding aspects in a set of requirements. Chapter two helps with the question "Why do we need them anyway?" Other chapters provide examples of how aspects can be applied in different kinds of systems, and provide details of Theme/UML, walking you through designing the aspects and the core of your system and capturing the specification of their composition.
AOP has proven to be of great use in modularizing source code and has provided a wide spectrum of benefits, from performance enhancement to more "evolvable" code. Aspect-oriented languages provide support for programming cross cutting concerns, or aspects, in one place and then automatically propagating the behavior to the many appropriate points of execution in the code. Cross cutting concerns are those parts of the program that, in standard design mechanisms, end up being scattered across multiple program modules and tangled with other modules. Aspects certainly should not be used as the hammer for every nail; however, aspect-orientation has been shown, when used properly and appropriately, to transform necessarily hairy code into something manageable and reasonable.