This is a progress report on an experiment to build a compile-time metaobject protocol for Scheme. The compilation setting raises issues not present in runtime oriented MOP's, due to the complexity of the domain and the coupling between different parts. To address the complexity of the domain, wehave developed a structure that decomposes the description of an implementation into a combination of many small, partially interacting, choices. To address the coupling, we have developed a decision making process that allows implementation choices to be made by a collaboration between user interventions and default decision making.

The view of abstraction on which software engineering is based does not support the reality of practic...

We now come to the decisive step of mathematical abstraction: we forget about what the symbols stand for... [The mathematician] need not be idle; there are many operations he can carry out with these symbols, without ever having to look at the things they stand for. Hermann Weyl, “The Mathematical Way of Thinking” (This appears at the beginning of the Building Abstractions With Data chapter of “Structure and Interpretation

Originally conceived as a neat idea that could help solve problems in the design and implementation of CLOS, the metaobject protocol framework now appears to have applicability to a wide range of problems that come up in high-level languages. This chapter sketches this wider potential, by drawing an analogy to ordinary language design, by presenting some early design principles, and by presenting an overview of three new metaobject protcols we have designed that, respectively, control the semantics of Scheme, the compilation of Scheme, and the static parallelization of Scheme programs.

A new kind of metaobject protocol, that controls the compilation of programs, allows users to participate in the compilation in a principled and modular way. Such a compiler makes it possible to program in a high-level language and still maintain control over crucial implementation issues. This result is that a number of simple and elegant Scheme programs can be compiled as efficiently as if they had been written with special purpose primitives. 1

In this paper we present an overview of the metaobject protocol approach to compilation. We take the position that object orientation in a compiler can be put to effective use in opening up the compiler for modification by the user. Interestingly, the natural scopes of effect of user intervention don't respect syntactic boundaries, so we require objects that are not just elements of the abstract syntax tree. We introduce a new kind of intermediate object for the process of compilation so that user modification of compilation strategies can be carried out in a coherent manner. We give some examples of user customizations, and outline the architecture of our Scheme compiler based on these principles.

This paper describes a methodology the authors found very useful in the development of open systems for objectoriented languages, user-interface builders and hypermedia. We promote the idea of "open designs" as being a key factor for success and discuss software engineering techniques useful in implementing such designs.