make decisions about an agent property while only
looking at its description and its interface with other
Smooth Transition in Software Life-Cycle Phases.
Aspect-oriented agent architectures are directly
mapped to implementation abstractions using well-known aspect-oriented programming languages, such
as AspectJ [ 1]. AspectJ, which extends the Java programming language, is the most popular aspect language. Architectural aspects are decomposed into a set
of AspectJ aspects and classes. The crosscutting interfaces are realized as pointcuts, advice, and inter-type
declarations, because they define different ways an
aspect affects other design and implementation modules. Join points are well-defined points in the
dynamic execution of the system components. Examples of join points are method calls and method executions. Pointcuts have a name and are collections of
join points. Advice is a special method-like construct
attached to pointcuts. Inter-type declarations introduce attributes, methods, and interface implementation declarations into the components to which the
crosscutting interface is attached. We have implemented an AspectJ framework that supports this
aspect-oriented architectural style at the implementation level [ 5]. It helps to guarantee a smooth transition
from the specification of heterogeneous agent architectures to their detailed design and implementation. We
have also developed several other aspect-oriented techniques to cope with agent aspects in different software
development phases in order to facilitate the traceability of the software engineering artifacts.
Coping with Dynamic Adaptability and Cus-tomizability. Architecting software agents with
improved separation of concerns is of paramount
importance in open, dynamic agent-based systems.
Dynamic reconfiguration of agent roles and collaboration protocols are often required as the agents move to
different environments. In addition, with the growing
number of applications for pervasive computing, the
selection of learning and coordination strategies may
depend on the context in which the agent is being executed. As such, agent architectures need to be designed
properly, and the dependency inversion gained with
aspect-oriented agent architectures is a key factor to
allow the agent adaptation and customization.
Numerous types of agent architectures are prevalent
[ 8] and must be developed in a way that meets the
stringent modern requirements of evolvability,
reusability, and dynamic reconfigurability. Existing
architectural styles are rigid by their very nature and
unable to cope with the crosscutting nature of agent
properties as well as the complexity of heterogeneous
agent architectures, which are often required in realistic modern systems. On the other hand, aspect-oriented software development is gaining wide
attention both in research environments and in
industry as a paradigm to promote improved modularity of complex software systems. The exploration
of aspect-oriented techniques clearly seems a promising step forward to allow the construction of more
flexible agent architectures and to foster enhanced
quality of realistic multi-agent systems. c
1. AspectJ Web site. The AspectJ Guide; eclipse.org/aspectj/.
2. Bergenti, F., Gleizes, M.-P., and Zambonelli, F., Eds. Methodologies
and Software Engineering for Agent Systems: The Agent-Oriented Software
Engineering Handbook, Volume 11. Springer-Verlag, 2004.
3. Bordini, R., Dastani, M., Dix, J., and Seghrouchni, A., Eds.
Multi-Agent Programming: Languages, Platforms, and Applications. Springer,
4. Buschmann, F. et al. Pattern-Oriented Software Architecture: A System of
Patterns. Wiley, NY, 1996.
5. Garcia, A., Lucena, C., and Cowan, D. Agents in object-oriented software engineering. Software: Practice and Experience 34, 5 (Apr. 2004),
6. Garcia, A. et al. Separation of concerns in multi-agent systems: An
empirical study. In C. Lucena et al., Eds., Software Engineering for
Multi-Agent Systems II, Springer-Verlag, LNCS 2940 (Mar. 2004),
7. Garcia, A. et al. Modularizing design patterns with aspects: A quantitative study. In Proceedings of the 4th ACM International Conference on
Aspect-Oriented Software Development (AOSD’05), 1– 11.
8. Jennings, N. An agent-based approach for building complex software
systems. Commun. ACM 44, 4 (Apr. 2001), 35– 41.
9. Kiczales, G. et al. Aspect-oriented programming. In Proceedings of the
European Conference on Object-Oriented Programming-ECOOP’ 97,
LNCS 1241, 220–242.
10. Rao, A. and Georgeff, M. BDI agents: From theory to practice. In V.
Lesser and L. Gasser, Eds., Proceedings of the 1st International Conference
on Multi-Agent Systems (ICMAS- 95), 312–319.
11. Soares, S, Laureano, E., and Borba, P. Implementing distribution and
persistence aspects with AspectJ. In Proceedings of the ACM Conference
on Object-Oriented Programming, Systems, Languages, and Applications
12. Ubayashi, N. and Tamai, T. Separation of concerns in mobile agent
applications. In Proceedings of the 3rd International Conference Reflection
2001, LNCS 2192, 89–109.
ALESSANDRO GARCIA ( email@example.com) is a lecturer of
computer science at Lancaster University, U.K.
CARLOS LUCENA ( firstname.lastname@example.org) is a professor of computer
science at Pontifical Catholic University of Rio de Janeiro, Rio de
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for
profit or commercial advantage and that copies bear this notice and the full citation on
the first page. To copy otherwise, to republish, to post on servers or to redistribute to
lists, requires prior specific permission and/or a fee.
© 2008 ACM 0001-0782/08/0500 $5.00