Aspect- And Integration-Oriented Programming
Aspect-oriented programming (AOP) is a new programming methodology that enables the modularization of crosscutting concerns. Experience has shown that using standard procedural or object-oriented programming languages it can be difficult to modularize design concerns such as:
- error-checking strategies
- design patterns
- synchronization policies
- resource sharing
- distribution concerns
- performance optimizations
The reason is that these kinds of concerns inherently tend to affect multiple modules -- synchronization is often between modules, similarly error-checking policy has to employ system-wide polices. Because of the way they cross module boundaries we say they crosscut the program structure.
Aspects are a new unit of software modularity that cleanly encapsulate crosscutting concerns. AOP facilitates working with aspects by providing explicit mechanisms for programming first-class crosscutting modularities. Aspects make the structure of the crosscutting concerns more clear and easy to reason about. They also make the interaction between the crosscutting concerns and the primary modularity clear.
Component technologies - such as JavaBeans/InfoBus, EJB, COM, COM+ - aim at similar targets: they are about freeing business logic of system level details. Component-oriented programming is based upon formulating rules that components must obey so that the target mentioned can be reached by the component framework. However, these rules are not integrated with languages.
Find more information concerning our view on the relation between component technologies and AOP in the following PowerPoint presentations: AC-AOP.zip and wcop01_2.ppt.
IOP is a model for aspect-oriented programming that integrates the ideas of component technology into languages. In that model, a component is a set of mutually recursive types that reference each other and call each other's methods to implement an aspect. Moreover, components are declaratively complete: an expected interface declares everything that is needed for the aspect's implementation but cannot be defined locally. There is no cross-cutting among the types and there are no explicit dependencies. The aspect is expressed in its own ontology.
A context defines an actual usage environment for several aspects by defining the borders separating them. These borders are put together from points in the execution chain of the contained components and the definition of how component behaviour changes at these points.
Objects always live inside a context. This context is their self reference. The default context (in Java: this) does not change a component's behaviour. Entering a context implicitly or explicitly yields a rebinding of the self reference.
State of the Art
Currently, a simplified version of this model exists in the form of the JADE (Java Adapter Extension) language where collaborating groups of objects can be automatically decorated with types. JADE only supports additive decoration with contexts - existing behaviour does not change. The model is developed in cooperation with
- Prof. Dr. L. Seiter, Princeton University,
- Prof. Dr. K. Lieberherr, Northeastern University,
There is also a new model for object-oriented composition wherein the principle of complete decoration, including change of existing behaviour, has been conceptually realized. The model is developed in cooperation with Dipl.-Inf. K. Ostermann (Siemens AG, Munich; Darmstadt University of Technology) as part of his PhD thesis. A paper describing one of the base technologies, compound references, has been accepted for presentation at OOPSLA 2001. By now, some PowerPoint slides are available.
Another simplified version of this model has been prototypically realized by in cooperation with Dipl.-Inf. S. Herrmann (TU Berlin). The implementation of the composition language LAC uses the reflexive language Lua and regards contexts as meta-programs influencing the connection model's functioning.
Research activities currently focus on integrating the connection point principle with a statically typed language (Java). Work regarding type system issues is also in progress.
Links to other research groups dealing with AOP: