A module system ought to enable assembly-line programming using separate compilation and an expressive linking language. Separate compilation allows programmers to develop parts of a program independently. A linking language gives programmers precise control over the assembly of parts into a whole. This paper presents models of program units, MzScheme's module language for assembly-line programming. Units support separate compilation, independent module reuse, cyclic dependencies, hierarchical structuring, and dynamic linking. The models explain how to integrate units with untyped and typed languages such as Scheme and ML.

Module and class systems have evolved to meet the demand for reuseable software components. Considerable effort has been invested in developing new module and class systems, and in demonstrating how each promotes code reuse. However, relatively little has been said about the interaction of these constructs, and how using modules and classes together can improve programs. In this paper, we demonstrate the synergy of a particular form of modules and classes—called units and mixins, respectively—for solving complex reuse problems in a natural manner.

The Meta-Modeling Language (MML) is a sub-set of the Unified Modeling Language (UML) that is proposed as the core language used to bootstrap the UML 2.0 definition initiative. Since it is metacircular, MML requires an external formal semantics in order to ground it. This paper defines the MML Calculus which is used to formally define MML and therefore provides a semantic basis for UML 2.0.

Most programming languages adopt static binding, but for distributed programming an exclusive reliance on static binding is too restrictive: dynamic binding is required in various guises, for example when a marshalled value is received from the network, containing identifiers that must be rebound to local resources. Typically it is provided only by ad-hoc mechanisms that lack clean semantics. In this

Programming languages offer a variety of constructs to support code reuse. For example, functional languages provide function constructs for encapsulating expressions to be used in multiple contexts. Similarly, object-oriented languages provide class (or class-like) constructs for encapsulating sets of definitions that are easily adapted for new programs. Despite the variety and abundance of such programming constructs, however, existing languages are ill-equipped to support component programming with reusable software components. Component programming differs from other forms of reuse in its emphasis on the independent development and deployment of software components. In its ideal form, component programming means building programs from off-the-shelf components that are supplied by a software-components industry. This model suggests a strict separation between the producer and consumer of a component. The separation, in turn, implies separate compilation for components, allowing a pr...

Nowadays the Net is one of the most obvious driving forces. Yet, to consider it as one global store through which values and code may be shared is still immature. This paper suggests first-class environments as a means to achieve that goal in a multi-user Scheme framework. We propose two new special forms with a simple semantics. Our model allows precise control over environments (including extensible environments) and does not require (but does not prevent) reflective operations. 1 Motivation Millions of users now dream of means through which they may share programs and/or data. Data are becoming more and more complex; they are no longer made of simple, atomic, flat values such as numbers or characters but now mundanely incorporate pointers, as exhibited by the increasing number of WWW pages full of references towards remote pieces of information. Other data are only acquired after long computations and are better shared rather than recomputed. Of course, data may be stored in share...

. This paper shows that class inheritance, viewed as a mechanism for composing self-referential namespaces, is a broadly applicable concept. We show that several kinds of software artifacts can be modeled as self-referential namespaces, and software tools based on a model of composition of namespaces can effectively manage these artifacts. We describe four such tools: an interpreter for compositionally modular Scheme, a compositional linker for object files, a compositional interface definition language, and a compositional document processing tool. We show that these tools benefit significantly from incorporating inheritance-based reuse. Furthermore, the implementation of these tools share much in common since they are based on the same underlying model. We describe a reusable OO framework for efficiently constructing such tools. Three of the above tools were built by directly reusing the application framework, and the fourth evolved in parallel with it. We provide reuse...

This dissertation presents a framework for the application of compositional modularity, a module model that facilitates extensive reuse of highly decomposed software. Compositional modularity supports not only the traditional notions of program decomposition and encapsulation but also effective mechanisms for module recomposition. Based on a previously developed model, a suite of operators individually achieve effects of adaptation and combination on a simple notion of modules viewed as self-referential namespaces. This dissertation extends the previous model by introducing the notion of hierarchical nesting as a composition operation. Furthermore, this work shows that compositional modularity is unifying in scope. Important effects and idioms of advanced modularity, including several varieties of inheritance in object-oriented programming, find convenient expression within this model. Compositional modularity can be applied within a wide range of systems that manipulate self-referenti...

We have studied a calculus with first-class environments which originates from the oe-calculus. We give a translation of the calculus to a record calculus and show fundamental properties by using the translation. First we give a translation of simply typed calculus ! env into simply-typed record calculus ! record , which is used for proving strong normalization of ! env . Second we introduce a translation of untyped calculus env into untyped -calculus and investigate extensional conversion of env-calculus with the translation. 1 Introduction First-class environments We treat various kinds of object in programming languages. Most of objects, e.g. integers or boolean values can be passed and returned between procedures. However, we cannot always use all of them in such a way. For example, procedures themselves are passed and returned between procedures in Lisp. In contrast, it is impossible to do so in BASIC. Objects which can be passed and returned between procedures, are sa...

Many Object-Oriented Programming Languages provide reflective features which may be used to control the interpretive mechanism of the language. Often, these features are defined with respect to a golden braid consisting of objects, classes and metaclasses. This paper describes the Smalltalk golden braid and generalize it for multiple inheritance. Multiple inheritance leads to choices between many different inheritance strategies. The reflective features of Smalltalk cannot affect the basic mechanisms of inheritance and so an arbitrary choice must be made for multiple inheritance. A language is described in which the reflective features of Smalltalk are extended so as to allow programmer defined inheritance strategies. 2 Introduction The evaluation of a programming language expression e in a given context c may be described by the evaluation of a program p which takes a representation of e and c as input. e is termed an object-level construct whilst p and the representations of e and ...