Theme: Putting Systems Together

Software techniques have developed enormously over the past 30-40 years, from primitive machine languages to sophisticated programming languages and tools for system configuration. We are working on the next great leap, shifting focus from programming-at-the-module level to programming-at-the-system level. In the former activity we build programs in terms of procedures and abstract data types using simple module interconnection as a way to compose modules; in the latter activity, we build systems in terms of more sophisticated components, often entire systems themselves, and compose them with more sophisticated abstractions for connection or interaction.

What makes the construction of composable systems different from programming?

1. We are liberating ourselves from thinking of the task as merely programming. We are not just building a program, we are building a system, where in the most general sense a system has not just software but hardware components as well.

2. Our units of manipulation are components and connectors. They may be primitive or composite. We describe components with interface specifications; connectors, protocol specifications. Our innovation is to make connectors first-class entities, just as components are, in a system. Program modules like procedures are examples of primitive components. Procedure call is one example of a primitive connector between two components. Designers use much richer interactions than procedure call, and so must our connectors. We want to support composite components and connectors whose properties, via their interface and protocol specifications, are as understandable as their constituents.

3. We want to provide ways to talk precisely about common patterns of system organization structures. This allows us to provide larger abstractions for system structuring. It also allows us to exploit special properties of particular composition idioms for analysis, design guidance, and efficient implementation.

Current composition technology falls short both for synthesis and analysis. On the synthesis side, we see a proliferation of specialized solutions, but no systematic support for sharing expertise or for resolving differences in interaction assumptions. On the analysis side, we need component-level analysis, but we have a poor understanding of interface abstractions, and our analysis techniques are too weak.