An Aspect-Oriented Approach - Autonomics Development: A Domain-Specific Aspect Language Approach - page 64

orientation, aspect-orientation as applied to autonomic systems, aspect-oriented
languages and aspect-oriented frameworks and their features and facilities.
Related work in using aspects for distribution, including frameworks, domain-
specific languages, Java language extensions and AspectJ approaches, have been
discussed.
We have discussed three common implementations of aspect-oriented sys-
tems:
1. The language-based approach, which is designed as an extension to an exist-
ing language.
2. The object-oriented framework-based approach, which provides a framework
that is used by developers to apply aspects to existing code.
3. The domain-specific aspect language approach, which uses a domain-specific
language to apply aspects to existing code.
AspectJ [6], an example of the first approach, extends the Java program-
ming language and provides a low level generalised approach to aspect-oriented
programming. Because AspectJ, and other language-based systems, are at a low
level they are relatively complicated to use. In addition, they introduce addi-
tional concepts and constructs, such as the notion of introductions, join points
and pointcuts, which further complicates their understanding.
The JBoss AOP [54] framework is an example of the framework-based ap-
proach as it allows programmers to define AOP constructs as Java classes using an
object-oriented framework. These constructs are used to alter the bytecode of the
target application using information contained in an XML file. Object-oriented
framework approaches are relatively easy to use compared to the language-based
approach as they use the same language as the application. However, this approach
requires developers to adhere to the framework's protocol, such as ensuring that
invocation.invokeNext() is called in an aspect, as is the case with the JBoss
AOP framework. Therefore, although framework-based approaches are easier to
use than language-based approaches, they require the programmer to have a good
understanding of the framework.
KALA [35], a domain-specific aspect language for the transactional domain,
is an example of the third approach as it uses a high-level domain-specific as-
pect language to apply aspects to existing code. Domain-specific aspect languages
require the developer to use a different language alongside the application lan-
guage and therefore require the programmer to learn a new language, although
the language is generally relatively simple. Nevertheless domain-specific aspect
languages, because they are at a higher level of abstraction, are generally much
simpler to use than the other two approaches.
A number of systems and proposals that use AOP to provide autonomics
have been discussed. However, none of these approaches are specifically targeted
at the distribution concern and therefore do not provide a means of implementing
recovery, nor do they generalise the distribution concern. Rather they are either