At the end of the micro-architecture discussion with the sorting machine, we discussed for some time issues related to the process of generalization. The point was that generality and composability were problematic if you connected components that didn't make sense together.
An important factor here is the choice of programming language and environment, which we discussed at length. Prem Devanbu mentioned the CMU Fox project [], a research project focused on the intersection of programming language design and system construction. One very interesting aspect of the project was that an extension of ML was used as the development language. This led us to discuss the use of ML functors to support the parameterization and instantiation process, important for system generalization. The group felt that a major problem here was simply the use of the not very widely accepted ML as a system development language.
A concern about the performance of highly parameterized and layered architectures was raised. A number of solutions currently under exploration in the research community were discussed.
Don Roberts, our OO representative, discussed his group's experience with refactoring as a way to redesign interfaces that get in the way of performance optimization [,]. This technique essentially involves remixing interfaces in order to generalize them and leverage previously separate design decisions, both important to evolving better overall architectural structures. The systematic software reuse group members observed that refactoring a system A to a system B looked very similar to the task of finding a generalization of both A and B, but the refactoring contigent pointed out that the goal of refactoring was essentially to find the most general architectural structure B.
Ron Biddle mentioned The Xerox PARC Open Implementation Project, led by Gregor Kiczales []. Their work with meta-object protocols is proposed as a controlled way to "break open" the abstraction cover to optimize implementation details previously thought to be taboo. Examples include optimizing real-time schedulers, operating system cache strategies, and layered network protocols.
Beat Liver pointed out that performance issues are system-wide properties. As such, optimization concerns are difficult to include in generalized reusable components, because the context in which the component is used is not known. His research group [] is therefore exploring the merging of conceptual model layers to obtain better performance. Examples are some implementations of the OSI stack [], where each conceptual model layer (corresponding to library components) is implemented as a separate subsystem.
It was then pointed out that there are a large number of decisions that the designer must always make, independent of whether or not they are supported by the specific programming language. This point was driven home by Don Batory in his Predator work []. His point was that his primary need from a language is to get the ability to "plug and play", not the ability to verify semantics. He was actually quite vehement about this, arguing that you can't run what you can't plug together. One take on this is that the semantic support people are actually spending a great deal of time on the wrong problem. Another (more reasonable) take is that it is the right problem, just not necessarily bound up solely with programming language issues.
The group agreed to disagree, realizing that there are many perspectives on what good language support is and what good language paradigms for reuse are. These need to be further mapped out and compared.