The first domain where we tested the practical advantages of our coordination perspective on software system design is the development of new applications by integrating existing software components. This section describes the experience gained by using SYNTHESIS to facilitate the reuse of existing software components in new applications.
One of the important practical diffculties of building new systems by reusing existing parts lies in the amount of effort required in order to bridge mismatches among components. In most cases some additional ''glue code''needs to be added to integrate all the independently written software pieces into a coherent application (Garlan et al. 1995). An application development tool based on the principles of our coordination perspective on software design has the potential of helping alleviate the diffculty of component integration by separating the representation of activities and dependencies, localizing information related to coordination protocols, and providing frameworks of common dependencies and coordination protocols.
To test this claim, we have used SYNTHESIS in order to build a set of test applications by reusing independently written pieces of software. Each experiment consisted in:
Describing a test application as a SYNOPSIS diagram
Selecting a set of components exhibiting various mismatches to implement activities
Using SYNTHESIS and its repository of dependencies in order to integrate the selected components into an executable system
Exploring alternative executable implementations based on the same set of components
The experiments are described in full detail in Dellarocas (1996). Table 18.1 provides a brief summary.
Experiment 1 consisted in building a simple File Viewer application by combining a commercial text editor and pieces of code written in C and Visual Basic. It demonstrated that the system is able to resolve low-level problems of interoperability, such as incompatibilities in programming languages, data types, procedure names, and control flow paradigms. It has also shown how the system can facilitate the exploratory design of alternative component organizations.
Experiment 2 investigated nine different ways of building an indexing system by various combinations of server and UNIX filter components (table 18.2). It provided positive evidence for the ability of the system to resolve architectural mismatches, that is, different assumptions about the structure of the application in which they will be used. It also demonstrated that the overall architecture of an application can be specified to a large extent independently of the implementation of any individual component, by appropriate selection of coordination processes.
|
Experiment |
Description |
Components |
Results |
|---|---|---|---|
|
File viewer |
A simple system that retrieves and displays the contents of user-selected files |
User interface component written in C; filename retrieval component written in Visual Basic; file display component implemented using commercial text editor |
Synthesis integrated components suggesting two alternative organizations (client/server, implicit invocation); all necessary coordination code was automatically generated in both cases |
|
Key word in context |
A system that produces a listing of all circular shifts of all input lines in alphabetical order (Parnas 1972) |
Two alternative implementations for each component (both written in C): as a server and as a UNIX filter |
Three different combinations of filter and server implementations were each integrated in 3 different organizations (see table 18.2). Synthesis generated most coordination code; users had to manually write 16 lines of code in 2 cases. |
|
Interactive TEX |
A system that integrates the standard components of the TEX document typesetting system in a WYSIWYG ensemble |
Standard executable components of TEX system |
Target application was completely described in Synopsis. Synthesis was able to generate coordination code automatically |
|
Collaborative editor |
A system that extends the functionality of existing single-user editors with group editing capabilities (Knister and Prakash 1990) |
Micro-Emacs source code was used to implement single-user editor (Lawrence and Straight 1989) |
Same system description was specialized in two different ways to generate micro-Emacs based group editors for Windows and UNIX |
Experiment 3 combined the standard components of the TEX document typesetting system in a WYSIWYG application. It tested the power of SYNOPSIS and our proposed vocabulary of dependencies in expressing nontrivial application architectures.
Finally, experiment 4 attempted to build a collaborative editor by extending the functionality of an existing text editor. It investigated the usefulness of the system in assisting the rapid development of applications for multiple platforms. It demonstrated that different implementations of the same application, suitable for different execution environments, can be generated from the same, partially specialized SYNOPSIS system description, by selecting different coordination processes for managing dependencies.
|
Components |
Architecture |
Auto lines[a] |
Manual lines[b] |
|
|---|---|---|---|---|
|
1 |
Filters |
Pipes |
34 |
0 |
|
2 |
Filters |
Main program/subroutine |
30 |
0 |
|
3 |
Filters |
Implicit invocation |
150 |
0 |
|
4 |
Servers |
Pipes |
78 |
16 |
|
5 |
Servers |
Main program/subroutine |
35 |
0 |
|
6 |
Servers |
Implicit invocation |
95 |
0 |
|
7 |
Mixed |
Pipes |
66 |
0 |
|
8 |
Mixed |
Main program/subroutine |
56 |
0 |
|
9 |
Mixed |
Implicit invocation |
131 |
16 |
| [a] Lines of coordination code automatically generated by Synthesis | ||||
| [b] Lines of coordination code manually added by user | ||||
Overall, our experiments provided positive evidence for the principal practical claims of the approach. The evidence can be summarized as follows:
Support for code-level software reuse. SYNTHESIS was able to resolve a wide range of interoperability and architectural mismatches and successfully integrate independently developed components into all four test applications, with minimal or no need for user-written coordination software.
Support for reuse of software architectures. SYNTHESIS was able to reuse a configuration-independent SYNOPSIS description of a collaborative editor and the source code of an existing single-user editor, in order to generate collaborative editor executables for two different execution environments (UNIX and Windows).
Insight into alternative software architectures. SYNTHESIS was able to suggest a variety of alternative overall architectures for integrating each test set of code-level components into its corresponding application, thus helping designers explore alternative designs.