Aspect-Oriented Programming

By Kim C. S. Pedersen.

General idea

Aspect-oriented programming (AOP) is a programming paradigm like object-oriented programming (OOP) and procedural-oriented programming (POP) are programming paradigms. AOP aims at reducing the amount of "tangled" code by which we mean code that might be implemented in different classes if a OOP language is used but still share important secondary requirements. Such requirements are said to cross-cut the system's basic functionality and are difficult to develop and maintain using non-AOP programming paradigms. Cross-cutting functionality can be thought of as functionalty spanning many objects.

Logging is the prototypical example of a cross-cutting concern. E.g. an application might use logging in multiple classes when methods are entered or exited. So even though the classes themselves have different responsibilities and are implemented differently they still perform the same secondary functionality, in this case, logging (for yet another example of a cross-cutting functionality see section one of article [2].

To sum up: The goal of AOP is to support the programmer in cleanly separating compontents and the cross-cutting concerns of these, in AOP-lingo called aspects, from each other. This is achieved by promoting the cross-cutting concerns to first-class program modules.
The goal of AOP is in contrast with OOP and POP in that those paradigms only separate components from each other.

Aspects and componets - two important terms

• An aspect - something which cannot be cleanly encapsulated in a generalized procedure (e.g. the functionality of a class in a OOP language). This means that an aspect is cross-cutting concern as defined in the paragraph above. An example of an aspect is the synchronization of concurrent objects. Many performance-related issues are aspects.
• A component - something that can be cleanly encapsulated in a generalized procedure. E.g. a GUI. A component can also be defined as something not sharing secondary requirements with other components.

How AOP works

In the general case, an AOP-based implementation of an application relies on a component language, an aspect language and an aspect weaver. The application consists of programs implementing the components, programs implementing the aspects and the weaving of the two types of programs. In article [1] the weaving results in C-code but recent AOP-development often use Java.

Languages supporting AOP

While OOP is supported by Java/C++ and other object-oriented languages, AOP is implemented as extensions to a number of programming languages, most notably AspectJ (Java) and AspectC++ (C++).

References

The above text relies on the following three articles:

1: Aspect-Oriented Programming,
Kiczales, Lamping, Mendhekar, Maeda, Lopes, Loingtier, Irwin,
Springer-Verlag 1997,
http://www2.parc.com/csl/groups/sda/publications/papers/Kiczales-ECOOP97/for-web.pdf.

2: Aspect-Oriented Programming,
Wikipedia - January 30, 2006,
http://en.wikipedia.org/wiki/Aspect_oriented_programming.

3: Cross Cutting,
Wikipedia - January 30, 2006,
http://en.wikipedia.org/wiki/Cross_cutting_%28programming%29.