make decisions about an agent property while only looking at its description and its interface with other concerns.

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.

 

CONCLUSION

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

 

REFERENCES

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, NY, 2005.

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), 489–521.

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), 49– 72.

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 (OOPSLA’02), 174–190.

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 ( [e-mail]) is a lecturer of computer science at Lancaster University, U.K.

CARLOS LUCENA ( [e-mail]) is a professor of computer science at Pontifical Catholic University of Rio de Janeiro, Rio de Janeiro, Brazil.

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