Advertisement

Software Quality Journal

, Volume 15, Issue 3, pp 283–307 | Cite as

Supporting high interoperability of components by adopting an agent-based approach

  • Wenpin JiaoEmail author
  • Hong Mei
Article

Abstract

While integrating components into systems, we will be confronted with problems concerned with the interoperability of components due to the interaction mismatches at multiple levels, such as interaction behaviors between components and features imposed by architectural styles. In this paper, we studied the interoperability of components and explored the approach to supporting high interoperability of components involved in mismatching interactions. First, we formalized components involved in different architectural styles in the pi-calculus. Next, we studied the formal foundation of the interoperability of components for reasoning about the conditions under which two heterogeneous components are possible to interoperate and interconnect together properly. Then, we described a wrapper-based solution for integrating components into systems that impose mismatching assumptions about usage of the components. In the end, we presented an agent-based implementation for the solution, in which agents are used to wrap components and can automatically resolve multiple levels of interaction mismatches between components. We also gave a simple example to illustrate our approach.

Keywords

Interoperability Component Wrapper Agent pi-Calculus 

Notes

Acknowledgements

This work is partially sponsored by the National Basic Research Program of China (973) under Grant No. 2002CB312003, the National Natural Science Foundation of China (Grant No. 60233010, 60303004, and 90412011), and the National High-Tech Research and Development Program of China (863) under Grant No. 2005AA112030.

References

  1. Abd-Allah, A. (1996). Composing heterogeneous software architectures. Doctoral Dissertation, Center for Software Engineering, University of Southern California.Google Scholar
  2. Allen, R., Douence, R., & Garlan, D. (1998). Specifying and analyzing dynamic software architectures. In Proceedings of conference on fundamental approach to software engineering, LNCS 1382, 21–37.Google Scholar
  3. Allen, R. J., & Garlan, D. (1997). A formal basis for architectural connection. ACM Transactions on Software Engineering and Methodology, 6(3), 213–249.CrossRefGoogle Scholar
  4. Balzer, R., & Goldman, N. (1999). Mediating connectors. In Proceedings of the 19th IEEE international conference on distributed computing systems, pp. 73–77.Google Scholar
  5. Bracciali, A., Brogi, A., & Canal, C. (2002). Systematic component adaptation. Electronic Notes in Theoretical Computer Science, 66(4).CrossRefGoogle Scholar
  6. Bray, T., Paoli, J., Sperberg-McQueen, C. M., & Maler, E. (2000). Extensible markup language (XML) 1.0 (Second Edition) Specification, World Wide Web Consortium (W3c). http://www.w3.org/TR/REC-xml.Google Scholar
  7. Canal, C., Pimentel, E., & Troya, J. M. (2001). Compatibility and inheritance in software architectures. Science of Computer Programming, 41, 105–138.MathSciNetCrossRefGoogle Scholar
  8. Chiang, C. C. (2003). The use of adapters to support interoperability of components for reusability. Information and Software Technology, 45(3), 149–156(8).CrossRefGoogle Scholar
  9. Compare, D., Inverardi, P., & Wolf, A. L. (1999). Uncovering architectural mismatch in component behavior. Science of Computer Programming, 33(2), 101–131.CrossRefGoogle Scholar
  10. Davis, L., Gamble, R. F., & Payton, J. (2002). The impact of component architectures on interoperability. Journal of Systems and Software, 61(11), 31–45.CrossRefGoogle Scholar
  11. Drools (2006). http://drools.org/.Google Scholar
  12. Ducasse, S., & Richner, T. (1997). Executable connectors: Towards reusable design elements. In ACM Foundations of Software Engineering (ESEC/FSE’97), LNCS 1301 (pp. 483–500). Springer Verlag.Google Scholar
  13. Egyed, A., & Balzer, R. (2006). Integrating COTS software into systems through instrumentation and reasoning. Automated Software Engineering, 13(1), 41–64.CrossRefGoogle Scholar
  14. Egyed, A., Medvidovic, N., & Gacek, C. (2000). Component-based perspective on software mismatch detection and resolution. IEE Proceedings-Software, 147(6), 225–236.CrossRefGoogle Scholar
  15. Finin, T., Labrou, Y., & Mayfield, J. (1997). KQML as an agent communication language. In J. M. Bradshaw (Ed.), Software agents (pp. 291–316). Menlo Park, California: AAAI Press/MIT Press.Google Scholar
  16. Forgy, C. L. (1982). Rete: A fast algorithm for the many pattern/ many object pattern match problem. Artificial Intelligence, 19(1982), 17–37.CrossRefGoogle Scholar
  17. Foundation for Intelligent Physical Agents (2002). http://www.fipa.org.Google Scholar
  18. Gacek, C. (1997). Detecting architectural mismatches during systems composition—an extension to the AAA model. Technical Report USC/CSE-97-TR-502, Center for Software Engineering, University of Southern California.Google Scholar
  19. Garlan, D., Allen, R., & Ockerbloom, J. (1995). Architectural mismatch or why it’s hard to build systems out of existing parts. IEEE Software, 12(6), 17–26.CrossRefGoogle Scholar
  20. Jiao, W., & Mei, H. (2003). Eliminating mismatching connections between components by adopting an agent-based approach. In Proceedings of the 15th IEEE international conference on tools with artificial intelligence, Sacramento, California, pp. 358–365.Google Scholar
  21. Jin, Y., & Han, J. (2005). Specifying interaction constraints of software components for better understandability and interoperability. In X. Franch & D. Port (Eds.), Proceedings of 4th international conference, ICCBSS 2005, Bilbao, Spain, LNCS 3412, pp. 54–64.Google Scholar
  22. Mei, H., Chen, F., Wang, Q., & Feng, Y. (2002). ABC/ADL: An ADL supporting component composition. In Chris George & Huaikou Miao (Eds.), Formal methods and software engineering, LNCS 2495 (pp. 38–47). Springer-Verlag.Google Scholar
  23. de Lemos, R., Gacek, C., & Romanovsky, A. (2003). Tolerating Architectural Mismatches. In R. de Lemos, C. Gacek, & A. Romanovsky (Eds.), Architecting dependable systems, LNCS 2677 (pp. 175–194). Berlin: Springer-Verlag.CrossRefGoogle Scholar
  24. Medvidovic, N., Oreizy, P., & Taylor, R. N. (1997). Reuse of off-the-shelf components in C2-style architectures. In Proceedings of the 1997 international conference on software engineering (ICSE’97), Boston, MA, pp. 692–700.Google Scholar
  25. Milner, R. (1993). The polyadic π-calculus: A tutorial. In W. Brauer, F. L. Bauer, H. Schwichtenberg (Eds.), Logic and algebra of specification. Springer-Verlag.Google Scholar
  26. Shaw, M., & Garlan, D. (1996). Software architecture: Perspectives on an emerging discipline. Prentice Hall.Google Scholar
  27. Wooldridge, M. J. (2002). Introduction to multiagent systems. New York: John Wiley and Sons.Google Scholar
  28. Yellin, D. M., & Strom, R. E. (1997). Protocol specifications and components adaptors. ACM Transaction on Programming Languages and Systems, 19(2), 292–333.CrossRefGoogle Scholar
  29. Zhu, P. (2005). Modeling and implementing autonomous components. Master Degree Thesis, Peking University.Google Scholar

Copyright information

© Springer Science+Business Media, LLC 2007

Authors and Affiliations

  1. 1.Institute of Software, School of Electronics Engineering and Computer SciencePeking UniversityBeijingChina

Personalised recommendations