Michael D. Rice
Computer Science Group
Department of Mathematics
Wesleyan University
Middletown, CT 06459
Tel: (860) 685-2184
Fax: (860) 685-2571
Email:
mrice@uts.cs.wesleyan.edu
Stephen B. Seidman
Department of Computer Science
Colorado State University
Fort Collins, CO 80523
Tel: (970) 491-5862
Fax: (970) 491-2466
Email:
seidman@cs.colostate.edu
The understanding and reuse of software architectures and designs can be greatly aided by the use of formal models of the architectural styles within which the architectures and designs were developed. The architecture style description language ASDL can be used to build such models.
Keywords: Reuse, understanding, software architectures, software architectural styles
Workshop Goals: Learning, networking, discussing issues related to the relevance of software architectures and architectural styles for design and architecture reuse.
Working Groups: Reuse process models, reuse education.
The term software architectural style refers to ``a set of design rules that identify the kinds of components and connectors that may be used to compose a system or subsystem, together with local or global constraints on the way the composition is done'' [1]. We have recently developed a formalism and methodology for describing software architectural styles. Our approach is summarized in an architectural style description language called ASDL [2] that has been used as the basis for a description of the Naval Research Laboratory's PGM [3, 4] hierarchical coarse-grain dataflow signal processing software architectural style. The resulting formalism will form part of an IEEE standard for PGM that is currently under development.
We believe that ASDL can also be used to describe other architectures corresponding to hierarchical software design methodologies. During the past decade, several such methodologies have been developed. In addition to PGM, they include PARSE [5] (targeted to parallel and distributed systems), HAMLET [6], CONIC [7] (targeted to reconfigurable distributed systems), and STILE [8]. While all of these methodologies were intended to encourage design reuse, their influence has often been limited to the research groups that developed them. A major problem with each methodology has been that each has its own idiosyncratic graphical syntax. Still worse, the corresponding semantics is either absent or poorly specified.
ASDL is based on a collection of software types. Each software type is associated with a Z schema that is invariant across all applications. Such schemas were used to describe module interconnection languages (MILs) in [9], and the Z schemas of [9] provide an initial substrate for ASDL.
The ASDL software types support the description of execution and interface semantics, logical views, and relationships between logical views. In addition, there are schemas that correspond to basic operations for modifying the state described by the software types. The use of Z schemas provides the language with a flexible and modifiable type-theoretic basis for describing, analyzing, and comparing various architectural styles and logical views. This is accomplished by (a) specifying the values of specific variables found in the schemas and constraints on those variables, and (b) by adding application-specific declarations, constraints, and operations to describe a particular logical view. The use of customized CSP [10] expressions permits the specification of execution and interface semantics. ASDL also contains a number of built-in operations that support the incremental description of the software types and serve as guides for the design of application-dependent operations.
A design developed with a graphical methodology consists of one or more diagrams whose components represent computations and communication paths. In some methodologies, an individual component can represent a parameterized family of computations and communications. While the graphical syntax and conventions used by these methodologies tend to be roughly similar, they differ in significant details. Beyond this, the semantics of the computations represented by the diagrams are difficult to infer from the diagrams themselves. The specifications and reference manuals for the methodologies are generally written in natural language, and they therefore do not provide much hard information about the semantics of a computation.
ASDL has proved very useful in providing a solid semantic foundation for PGM. Although the ASDL model of PGM is relatively abstract, we have been able to use it to produce an ``intermediate'' PGM formalism that has proved to be easily comprehensible by computer scientists and signal processing engineers. This formalism provides guidance to the engineers who are producing application architectures within the PGM style, and to the implementors who are building systems that will execute these architectures. This should greatly increase the understanding of PGM architectures, and therefore also increase the potential for their reuse.
We are currently using ASDL to model the software architectural style corresponding to the PARSE development methodology, and we hope that the PARSE model will prove to be as useful as the PGM model has been. We believe that our approach will be both useful and valid across a broad range of architectural styles corresponding to hierarchical graphical software design methodologies.
Research on software architectural styles has been carried out at Carnegie-Mellon University by a group directed by Mary Shaw [1]. A primary goal of this group is to organize and classify a number of commonly recognized styles in order to establish a uniform descriptive standard for architectural styles that will support retrieval of style information, to provide a basis for discriminating among styles, and to provide advice to the software architect on the selection of appropriate styles. The intention is to replace the box and line diagrams and informal prose constraints that are generally used to describe the architectural style of a system with descriptions that will be more reliable across the community of software architects. To do this, an architectural style is characterized with respect to values corresponding to the following variables: ``kinds of components and connectors'', ``control issues'', ``data issues'', ``control/data interaction'', and ``type of reasoning''. Information is tabulated in [1] for styles ranging from ``dataflow network'' to ``classical objects'' and ``client-server''. Since the variables are not defined formally and the semantics associated with the values of variables are unstated (e.g. the value of ``component'' can be ``process'', ``manager'', or ``procedure''), it is hard to see how such information can form the basis for a uniform and reliable descriptive standard. At best, it constrains the informality by restricting it to the cells of a taxonomy.
A second Carnegie-Mellon research group, directed by David Garlan, is also working on architectural styles [11]. Garlan's group is concerned with giving formal definitions to the semantic constraints imposed by a style on the way in which the components and connectors of an architecture can be assembled. To do this, they first give a high-level syntax for the elements that comprise an architecture. They then define a semantic model for the components and connectors of a particular style, and show how the semantics can be used to give meaning to the elements of an architecture constructed in that style. Finally, they give specific syntactic preconditions that an architecture must satisfy to be regarded as a representative of the style. Their approach is applied to two styles: a pipe-filter style and an event system style. The explicit separation of architectural syntax and semantics that is required by this approach seems cumbersome, indirect, and somewhat artificial. By comparison, ASDL is based on an integrated perspective that combines execution and interface semantics with the architectural syntax provided by a formal MIL model [9].
Our methods and goals differ sharply from those of the projects described above. Our emphasis on the need to give a formal specification of the execution and interface semantics of the components of a software architecture contrasts with the informality of the variables and values used in the descriptions of [1]. Our emphasis on using ASDL to model industrial-strength architectural styles contrasts with [11], which applies the Garlan group's formalism to high-level abstract styles. It is not clear that the approach of [11] will scale to industrial-strength styles like PGM.
The goal of our approach is to use the ASDL formalism to gain an understanding of hierarchical architectural styles that will support increased understanding of architectures developed within those styles; this will in turn make it easier to use these architectures.
Michael D. Rice is Associate Professor of Computer Science at Wesleyan University in Middletown, CT. His research is in the areas of formal methods, software architectures, and applications of topological ideas to computer science. Before coming to Wesleyan in 1990, Rice was Associate Professor of Computer Science at George Mason University. He received the Ph.D. in Mathematics from Wesleyan University in 1973.
Stephen B. Seidman is Professor of Computer Science and Chair of the Department of Computer Science at Colorado State University in Fort Collins, CO. His research is in the area of formal models for software architectures and software architectural styles. He is also directing a project to develop an IEEE standard for the PGM software architectural style. Before coming to Colorado State in 1996, Seidman was Professor of Computer Science and Engineering and Head of the Department of Computer Science and Engineering at Auburn University. He came to Auburn from George Mason University, where he was Professor of Computer Science, in 1990. He received the Ph.D. in Mathematics from the University of Michigan in 1969.