Aspect-Oriented Software Development (AOSD), sometimes just called
Aspect-Oriented Programming (AOP), is a new approach to software design that addresses modularity problems that are not handled well by other approaches, including
Structured Programming and
Object-Oriented Programming (OOP). AOSD complements, but doesn't replace those approaches.
Typical enterprise and internet applications today have to address "concerns" like security, transactional behavior, logging,
etc.. The subsystems that provide these services can be implemented in a modular way. However, to use these services, you must insert the same "boilerplate" code fragments into various places in the rest of the application to invoke these services. This violates the "don't repeat yourself" (DRY) principle and it compromises the overall system modularity, because the same invocation code is
scatteredthroughout the application.
For example, if you want to control access to certain services in your application, you could insert authorization-checking boilerplate at the beginning of every method that needs this control. Because this redundant boilerplate appears in many places in the code, it would now be difficult and error prone to modify or replace this security approach later, should that become necessary. Also, your application code is now
tangled with code for the security (and probably other) concerns, which both compromises clarity and makes it hard to reuse your code in another context, since you would have to drag along the same security approach, which may not be appropriate.
Because concerns like security typically cut across a number of application module boundaries (
e.g., classes). We call them
cross-cutting concerns.
Note that the loss of modularity is at the
intersection between the different concerns. AOP restores modularity by developing the cross-cutting concerns, or
aspects, in isolation and then combining them with other modules using declarative or programmatic mechanisms that are modular. That is, the points of intersection are defined once, in one place, making them easy to understand and maintain. The other modules require no modifications to be
advised by the aspects. This "intersection" process, sometimes called
weaving, can occur at build or run time. AOSD weaving is a key innovation that provides very fine grained query and composition semantics. Where traditional code linking has the ability to resolve method and variable names, weaving adds the ability to replace method bodies with new implementations, insert code before and after method calls, instrument variable reads and writes, and even associate new state and behavior with existing classes, typically for adding "mixin" behaviors.
For more info check
AOSD web site.
