Supporting architectural concerns in component interoperability standards

There has been considerable work in industry on the development of component-interoperability models, such as COM, CORBA and JavaBeans. These models are intended to reduce the complexity of software development and to facilitate reuse of off-the-shelf components. The focus of these models is syntactic interface specification, component packaging, intercomponent communication, and bindings to a runtime environment. What these models lack is a consideration of architectural concerns—specifying systems of communicating components, explicitly representing loci of component interaction, and exploiting architectural styles that provide well understood global design solutions. The work described involves introducing support for architectural concerns in component models, particularly studying techniques to support notions of architectural style and explicit connectors. The JavaBeans component model has been enhanced to support component composition according to the C2 architectural style. The approach enables the design and development of applications in the C2 style using off-the-shelf Java components or `beans' that are available to the designer. The techniques underlying the approach are described, along with a composition environment called `ARABICA' that embodies these techniques. A number of important issues that must be addressed when extending component standards to support architectural concerns are identified.

[1]  Peyman Oreizy,et al.  Reuse of Off-the-Shelf Components in C2-Style Architectures , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[2]  Mary Shaw,et al.  Software architecture - perspectives on an emerging discipline , 1996 .

[3]  David S. Rosenblum,et al.  Exploiting ADLs to specify architectural styles induced by middleware infrastructures , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

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

[5]  Clemens A. Szyperski,et al.  Component software - beyond object-oriented programming , 2002 .

[6]  David Garlan,et al.  Exploiting style in architectural design environments , 1994, SIGSOFT '94.

[7]  Nenad Medvidovic,et al.  Integrating architecture description languages with a standard design method , 1998, Proceedings of the 20th International Conference on Software Engineering.

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

[9]  Jeff Magee,et al.  Composing distributed objects in CORBA , 1997, Proceedings of the Third International Symposium on Autonomous Decentralized Systems. ISADS 97.

[10]  David Flanagan Java Enterprise in a Nutshell , 1999 .

[11]  Gregory D. Abowd,et al.  Using style to understand descriptions of software architecture , 1993, SIGSOFT '93.

[12]  David Garlan,et al.  Architectural Mismatch: Why Reuse Is So Hard , 1995, IEEE Softw..

[13]  Grady Booch,et al.  Essential COM , 1998 .

[14]  Richard N. Taylor,et al.  A Component- and Message-Based Architectural Style for GUI Software , 1995, 1995 17th International Conference on Software Engineering.

[15]  Naranker Dulay,et al.  Regis: a constructive development environment for distributed programs , 1994, Distributed Syst. Eng..

[16]  Peyman Oreizy,et al.  Architecture-based runtime software evolution , 1998, Proceedings of the 20th International Conference on Software Engineering.

[17]  Jason E. Robbins,et al.  Extending design environments to software architecture design , 1996, Proceedings of the 11th Knowledge-Based Software Engineering Conference.

[18]  Mehdi Jazayeri,et al.  Component Programming - a Fresh Look at Software Components , 1995, ESEC.

[19]  Sylvia Stuurman,et al.  Software Architecture and Java Beans , 1999 .

[20]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[21]  Raghu V. Hudli,et al.  CORBA fundamentals and programming , 1996 .

[22]  Richard N. Taylor,et al.  Using off-the-shelf middleware to implement connectors in distributed software architectures , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[23]  Harald C. Gall,et al.  The architectural style of component programming , 1997, Proceedings Twenty-First Annual International Computer Software and Applications Conference (COMPSAC'97).

[24]  Hans H. Kron,et al.  Programming-in-the-Large Versus Programming-in-the-Small , 1975 .