This paper examines different strategies for linking separately-compiled software modules together at load time. Two of the strategies, load-time code generation and load-time compilation have only recently become practical on account of faster processors. It is likely that one of these new techniques will displace the currently popular linking-loader approach, as it promises the profound additional benefit of cross-platform portability. As general-purpose operating systems move forward to embrace dynamic linking and compound-document architectures, the technologies they choose for linking components will play a pivotal role for their long-term commercial success.

Lagoona is a strongly-typed object-oriented programming language based on Oberon. Lacking the class construct found in traditional object-oriented languages, Lagoona separates many of the concerns usually subsumed by classes, such as encapsulation, structure, and behavior, turning them into independent language constructs. A rich data model is provided that can express the difference between specialization and combination, two relations that are otherwise often both mapped onto subtyping.

In contrast to most strongly-typed object-oriented languages, Lagoona's messages are not subordinate to classes, but are stand-alone entities that can be combined with arbitrary objects. A delegation mechanism is provided, by which objects can forward received messages even if they do not "understand" their contents. Lagoona's particular message-send semantics make the construction of extensible systems simple and elegant.

We are designing and implementing a flexible infrastructure for mobile-object systems. Two fundamental innovations distinguish our architecture from other proposed solutions. First, our representation of mobile code is based on adaptive compression of syntax trees. Not only is this representation more than twice as dense as Java byte-codes, but it also encodes semantic information on a much higher level than linear abstract-machine representations such as p-code or Java byte-codes. The extra structural information that is contained in our mobile-code format is directly beneficial for advanced code optimizations.

Second, our architecture achieves superior run-time performance by integrating the activity of generating executable code into the operating system itself. Rather than being an auxiliary function performed off-line by a stand-alone compiler, code generation constitutes a central, indispensable service in our system. Our integral code generator has two distinct modes of operation: instantaneous load-time translation and continuous dynamic re-optimization.

In contrast to just-in-time compilers that translate individual procedures on a call-by-call basis, our system's integral code-generator translates complete code-closures in a single burst during loading. This has the apparent disadvantage that it introduces a minor delay prior to the start of execution. As a consequence, to some extent we have to favor compilation speed over code quality at load time.

But then, the second operation mode of our embedded code generator soon corrects this shortcoming. Central to our run-time architecture is a thread of activity that continually optimizes all of the already executing software in the background. Since this is strictly a re-compilation of already existing code, and since it occurs completely in the background, speed is not critical, so that aggressive, albeit slow, optimization techniques can be employed. Upon completion, the previously executing version ofthe same code is supplanted by the newly generated one and re-optimization starts over. By constructing globally optimized code-images from mobile software components, our architecture is able to reconcile dynamic composability with the run-time efficiency of monolithic applications.