next up previous
Next: Command processor support Up: No Title Previous: Compiling and linking

Semantics of configuration mutation

During program development it is often desirable to make changes to packages and interfaces. In static languages it may be necessary to recompile and re-link a program in order for such changes to be reflected in a running system. Even in interactive Common Lisp implementations, a change to a package's exports often requires reloading clients that have already mentioned names whose bindings change. Once read resolves a use of a name to a symbol, that resolution is fixed, so a change in the way that a name resolves to a symbol can only be reflected by re- reading all such references.

The Scheme 48 development environment supports rapid turnaround in modular program development by allowing mutations to a program's configuration, and giving a clear semantics to such mutations. The rule is that variable bindings in a running program are always resolved according to current structure and interface bindings, even when these bindings change as a result of edits to the configuration. For example, consider the following: =0pt=0pt=0pt =0pt[] (define-interface foo-interface (export a c)) (define-structure foo foo-interface (open scheme) (begin (define a 1) (define (b x) (+ a x)) (define (c y) (* (b a) y)))) (define-structure bar (export d) (open scheme foo) (begin (define (d w) (+ (b w) a))))

This program has a bug. The variable b, which is free in the definition of d, has no binding in bar's package. Suppose that b was supposed to be exported by foo, but was omitted from foo-interface by mistake. It is not necessary to re-process bar or any of foo's other clients at this point. One need only change foo-interface and inform the development system of that one change (using, say, an appropriate Emacs command), and foo's binding of b will be found when procedure d is called.

Similarly, it is also possible to replace a structure; clients of the old structure will be modified so that they see bindings from the new one. Shadowing is also supported in the same way. Suppose that a client package C opens a structure foo that exports a name x, and foo's implementation obtains the binding of x as an import from some other structure bar. Then C will see the binding from bar. If one then alters foo so that it shadows bar's binding of x with a definition of its own, then procedures in C that reference x will automatically see foo's definition instead of the one from bar that they saw earlier.

This semantics might appear to require a large amount of computation on every variable reference: The specified behavior requires scanning the package's list of opened structures, examining their interfaces, on every variable reference, not just at compile time. However, the development environment uses caching with cache invalidation to make variable references fast.



next up previous
Next: Command processor support Up: No Title Previous: Compiling and linking



Margaret M Fleck
Tue Nov 5 21:13:16 CST 1996