A basic model for components implementation of software architecture

Components defined in software architecture have two features: as basic elements of the architecture, they must conform to the architectural constraints and in the meantime, similar to the common components, they should be designed flexibly enough to be able to be developed independently for the late third party integration. However, these two important issues have always been handled separately from different point of views, which leads to the extra work, confusions in the program structures as well as the difficulty in maintenance. This paper presents a basic model of the architecture-based components implementation to band these two issues together. It firstly describes a novel design pattern, triple-C pattern which stands for <u>C</u>omponents-<u>C</u>ommunicate-through-<u>C</u>onnector. This pattern not only emphasizes that implementation must completely conform to the architectural definition, but also attempts to change the fundamental way of components communication with suggesting provided service should be transferred through the connector instead of directly between the client and server components. Second, it describes a novel ADL JCMPL, toolset JCMP and techniques to keep architectural conformance in the implementation as well as support the architectural integration from separate components. Finally, this model is evaluated in a case study.

[1]  William G. Griswold,et al.  Dynamically discovering likely program invariants to support program evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[2]  Dale Rogerson,et al.  Inside COM , 1997 .

[3]  Matthew Flatt,et al.  Jiazzi: new-age components for old-fasioned Java , 2001, OOPSLA '01.

[4]  Paul Clements,et al.  Software product lines - practices and patterns , 2001, SEI series in software engineering.

[5]  David Notkin,et al.  Language Support for Connector Abstractions , 2003, ECOOP.

[6]  Jeannette M. Wing,et al.  Specification matching of software components , 1995, TSEM.

[7]  Peyman Oreizy,et al.  Using object-oriented typing to support architectural design in the C2 style , 1996, SIGSOFT '96.

[8]  João Costa Seco,et al.  A Basic Model of Typed Components , 2000, ECOOP.

[9]  Alexander L. Wolf,et al.  Acm Sigsoft Software Engineering Notes Vol 17 No 4 Foundations for the Study of Software Architecture , 2022 .

[10]  Robert Leroy Kruse,et al.  Data structures and program design , 1984 .

[11]  Vugranam C. Sreedhar,et al.  Mixin'Up components , 2002, ICSE '02.

[12]  Guoqing Xu,et al.  JMLAutoTest: A Novel Automated Testing Framework Based on JML and JUnit , 2003, FATES.

[13]  J. J. Whelan,et al.  5th international conference on software engineering , 1981, SOEN.

[14]  Matthias Felleisen,et al.  Units: cool modules for HOT languages , 1998, PLDI.

[15]  Yoonsik Cheon,et al.  A Runtime Assertion Checker for the Java Modeling Language (JML) , 2003, ICSE 2003.

[16]  Richard N. Taylor,et al.  A Classification and Comparison Framework for Software Architecture Description Languages , 2000, IEEE Trans. Software Eng..

[17]  Jeff Magee,et al.  Dynamic structure in software architectures , 1996, SIGSOFT '96.

[18]  Albert L. Baker,et al.  Preliminary design of JML: a behavioral interface specification language for java , 2006, SOEN.

[19]  Xiaolei Qian,et al.  Correct Architecture Refinement , 1995, IEEE Trans. Software Eng..

[20]  David Notkin,et al.  Architectural Reasoning in ArchJava , 2002, ECOOP.

[21]  David S. Rosenblum,et al.  Supporting architectural concerns in component interoperability standards , 2000, IEE Proc. Softw..

[22]  Mary Shaw,et al.  Abstractions for Software Architecture and Tools to Support Them , 1995, IEEE Trans. Software Eng..

[23]  David Garlan,et al.  A formal basis for architectural connection , 1997, TSEM.

[24]  David Notkin,et al.  ArchJava: connecting software architecture to implementation , 2002, ICSE '02.

[25]  허진호 [參觀記] European Conference on Object Oriented Programming 참관기 , 1988 .

[26]  Robert L. Kruse,et al.  Data structures and program design in C , 1986 .

[27]  Mary Shaw,et al.  An Introduction to Software Architecture , 1993, Advances in Software Engineering and Knowledge Engineering.

[28]  Thomas J. Mowbray,et al.  Inside CORBA - distributed object standards and applications , 1998, Addison-Wesley object technology series.

[29]  Mira Mezini,et al.  Integrating independent components with on-demand remodularization , 2002, OOPSLA '02.

[30]  Mira Mezini,et al.  Component Integration with Pluggable Composite Adapters , 2002 .

[31]  David C. Luckham,et al.  An Event-Based Architecture Definition Language , 1995, IEEE Trans. Software Eng..