The viewpoint of stratified design is that a complex design should be described in terms of a sequence of levels of description. Each level describes how parts of the design are constructed from elements that are regarded as primitive at that level. The parts constructed at each level are used as primitives at higher levels.
The point of stratification is to make designs that are robust. Robust design requires that, at each level, the descriptive framework be rich enough so that small modifications of the design are only slightly different in description. We must allow for after-the-fact changes in the design plan as bugs are discovered and as requirements change. The way to do this is to make sure that each level of the system has more generality than is needed for the particular application at hand.
In traditional ``structured'' methodologies, systems are designed as predetermined combinations of parts that have been carefully specified. In a stratified design, each system component is constructed using a language that gives access to an entire space of choices, not just to one particular choice.
In electrical design, for example, resistors and transistors are combined as analog circuits to make TTL, a language appropriate to digital circuits. TTL parts are in turn combined to build processors, bus structures, and memory systems appropriate to computer architecture. Someone who is designing a memory system has the option of choosing a different TTL part, or (in principle) of constructing a new TTL part from resistors and transistors.
The open implementation view is part and parcel of the same idea. Open implementation holds the elements of the programming language or system that we are using are not fixed, black-box entities, but rather things whose behavior can be modified. The place where the stratified design perspective helps is that it reminds us that these elements we are modifying are themselves points in design spaces (which the paper refers to as spaces of ``mapping decisions'').
This bears on one of the paper's main questions, namely, what are good principles for opening an implementation? The stratified design perspective emphasizes that the elements whose behavior we are ``opening'' are created as constructs in a language, which has its own primitives, means of combination, and means of abstraction. This is the language that we expose to the user when we open the implementation.
The ease with which an open implementation can be managed boils down to the coherence of these ``lower-level'' languages. Pragmas, for example, reflect restricted languages that permit user to tweak parameters in a highly constrained way. MOPS are a technique that applies object-oriented constructs to control modularity in the lower-level languages. The general point is that the lower-level languages are languages, and whatever effective linguistic techniques we can bring to bear will be useful in managing the open implementation.
The paper characterizes open implementations as providing two interfaces for programmers -- an interface to the functionality and an interface to the implementation of the underlying modules. The stratified design viewpoint is that there are a multiplicity of interfaces. Sometimes these interfaces are organized hierarchically. (Perhaps this is what the paper is getting at in the discussion of MOP ``layered protocols'' .) But the important point is that each interface should be expressed in a coherent language that provides structured access to the design choices made at that level. For example, one could imagine a distributed memory system with two ``implementation interfaces:'' a set of pragmas to control replication decisions and a MOP to control distribution decisions. There's nothing wrong with a multiplicity of interfaces in different linguistic styles. What's important is that each interface have a linguistic structure appropriate to its task.
From the stratified design perspective, the considerations of how one goes about creating effective open implementations are not very different from how one goes about creating any kind of effective layered system. The open implementation emphasis is to remind us that the layers don't stop with the ``primitives'' of the language, and that the primitives (and subprimitives) are themselves points in design spaces that should be managed with appropriate linguistic frameworks.
Back to Alphabetical List of Responses
(Last Revised October 1994)