On the Modularity Assessment of Aspect-Oriented Multi-Agent Systems Product Lines: a Quantitative Study

• Camila Nunes PUC-Rio
• Uirá Kulesza UFRN
• Cláudio Sant'Anna PUC-Rio
• Ingrid Nunes PUC-Rio
• Carlos Lucena PUC-Rio

DOI: https://doi.org/10.5753/sbcars.2008.46265

Resumo

This paper presents a quantitative study of development and evolution of a multi-agent systems product line (MAS-PL). The investigated MAS-PL is obtained from the initial version of a conference management web-based system, named Expert Committee (EC), that is gradually evolved to incorporate a series of change scenarios related to new agency features (autonomous behavior). The quantitative study consists of a systematic comparison between two different versions of the MAS-PL: (i) one version implemented with object-oriented techniques and conditional compilation; and (ii) the other one using aspect-oriented techniques. Our analysis was driven by fundamental modularity attributes, such as: separation of concerns, interaction between concerns, and program size.

Referências

Alur, D., et al. (2001). Core J2EE Patterns: Best Practices and Design Strategies. Prentice Hall PTR, Upper Saddle River, NJ, USA.

Alves, V., et al. (2006). Refactoring product lines. In Proceedings of the 5th GPCE’05, pp. 201–210, New York, NY, USA. ACM.

Alves, V., et al. (2005). Extracting and evolving mobile games product lines. In Proceedings of the 9th SPLC’05, pp. 70–81. Springer.

Apel, S. and Batory, D. (2006). When to use features and aspects?: a case study. In Proceedings of the GPCE’06, pp. 59–68, New York, USA. ACM.

Buschmann, F., et al.: Pattern-Oriented Software Architecture: A System of Patterns. John Wiley Sons (1996).

Clements, P. and Northrop, L. (2002). Software Product Lines: Practices and Patterns. Addison-Wesley, Boston, USA.

Colyer, A., et al. (2004). On the separation of concerns in program families. Technical report, Computing Department, Lancaster University.

Czarnecki, K. and Eisenecker, U. (2000). Generative Programming: Methods, Tools, and Applications. Addison Wesley Longman.

Czarnecki, K. and Helsen, S. (2006). Feature-based survey of model transformation approaches. IBM Systems Journal, 45(3):621–645.

Figueiredo, E., et al. (2008). Evolving software product lines with aspects: An empirical study on design stability. In Proceedings of the 30th ICSE’08, pp. 261-270.

Filho, F. C., et al. (2006). Exceptions and aspects: the devil is in the details. In SIGSOFT FSE, pp. 152–162.

Garcia, A., et al. (2003). Agents and Objects: An Empirical Study on the Design and Implementation of Multi-Agent Systems. In SELMAS’03, pp. 11–21, USA.

Garcia, A., et al. (2005). Modularizing design patterns with aspects: a quantitative study. In Proceedings of the 4th AOSD’05, pp. 3–14, NY, USA. ACM Press.

Greenfield, J., et al. (2004). Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools. John Wiley and Sons.

Greenwood, P., et al. (2007). On the impact of aspectual decompositions on design stability: An empirical study. In Proceedings of ECOOP’07, LNCS, pp. 176–200.

Griss, M. L. (2000). Implementing product-line features by composing aspects. In Proceedings of the first SPLC, pp. 271–288, Norwell, MA, USA.

Hannemann, J. and Kiczales, G. (2002). Design pattern implementation in Java and aspectJ. In OOPSLA ’02: Proceedings of the 17th ACM SIGPLAN, pp 161–173.

Hunleth, F. and Cytron, R. K. (2002). Footprint and feature management using aspect-oriented programming techniques. SIGPLAN Not., 37(7):38–45.

Jennings, N. R. (2001). An agent-based approach for building complex software systems. Commun. ACM, 44(4):35–41.

Kastner, C., et al. (2007). A case study implementing features using aspectj. In Proceedings of the 11th SPLC’07, pp. 223–232,Washington, DC, USA.

Kiczales, G., et al. (1997). Aspect-Oriented Programming. In Proceedings of ECOOP 1997, v. 1241, pp. 220–242, Berlin, Heidelberg. Springer-Verlag.

Kulesza, U., et al. (2006a). Improving Extensibility of Object-Oriented Frameworks with Aspect-Oriented Programming. In ICSR’06, pp. 231–245, Torino.

Kulesza, U., et al. (2006b). Quantifying the effects of aspect-oriented programming: A maintenance study. In Proceedings of the 22nd ICSM’06, pp. 223–233.

Lee, K.,et al. (2006). Combining feature-oriented analysis and aspect-oriented programming for product line asset development. In Proceedings of the 10th SPLC’06, pp. 103–112,Washington, DC, USA. IEEE Computer Society.

Nunes, I., et al. (2008). Developing and evolving a multi-agent system product line: An exploratory study. In 9th AOSE’08, pp. 177-188, Estoril, Portugal.

Pena, J., et al. (2006a). Managing the Evolution of an Enterprise Architecture Using a MAS-Product-Line Approach. Software Engineering Research and Practice, pp. 995–1001. CSREA Press.

Pena, J., et al. (2006b). Building the core architecture of a multiagent system product line: with an example from a future nasa mission. In 7th AOSE’06. LNCS.

Pohl, K., et al. (2005). Software Product Line Engineering:Foundations, Principles and Techniques. Springer-Verlag, New York,USA.

Sant’Anna, C., et al. (2007). On the modularity of software architectures: A concern-driven measurement framework. In ECSA’07, v. 4758, pp. 207–224.

Sant’Anna, C., et al. (2003). On the Reuse and Maintenance of Aspect-Oriented Software: An Assessment Framework. In Proceedings XVII of SBES’03, pp. 19–34.

Soares, S., et al. (2006). Distribution and persistence as aspects. Software Practice Experience, 36(7):711–759.

Wooldridge, M. and Ciancarini, P. (2000). Agent-Oriented Software Engineering: The State of the Art. First Int. Workshop on AOSE, v. 1957, pp. 1–28.

Gamma, E., et al.: Design Patterns: Elements of Reusable Object-oriented Software. Addison-Wesley (1995).

Eaddy, M., et al. (2008): Do crosscutting concerns cause defects?. IEEE Transactions on Software Engineering, to appear.