Thesis on Flexible Encapsulation available

This is an unabashed plug for my thesis ``Flexible Encapsulation.'' The
thesis describes the new modular object-oriented programming language Zuse
and its family of translating systems. Zuse is novel in that it allows any
aspect of any exported item to be either hidden or revealed. In
particular, Zuse supports fully abstract types which are similar to
Modula-2 and Modula-3's opaque types but without the restriction that such
types must be implemented as pointers. Furthermore, the Zuse translating
systems (which employ distributed or incremental techniques) ensure that
there is no extra cost involved in the use of a fully or partially hidden
item. The translating systems furthermore support inter-modular
optimization techniques such as inline expansion.


Send me your snail-mail address and I will send you a copy. The thesis
abstract follows at the end of this message.


Christian Collberg


Christian.Collberg@dna.lth.se
Department of Computer Science, Lund University,
BOX 118, S-221 00 LUND, Sweden


---------------------------------------------------------------------------
Most modular programming languages provide an encapsulation concept. Such
concepts are used to protect the representational details of the
implementation of an abstraction from abuse by its clients. Unfortunately,
strict encapsulation is hindered by the separate compilation facilities
provided by modern languages. The goal of the work presented here is to
introduce techniques which allow modular languages to support both
separate compilation and strict encapsulation without undue
translation-time or execution-time cost.


The thesis is divided into four parts. The first part surveys existing
modular languages and modular language translation techniques. The second
part presents the experimental modular imperative and object-oriented
language Zuse, which supports strict and flexible encapsulation
facilities. The third part describes four translation system designs for
Zuse based on high-level module binding. The fourth part evaluates these
systems.


The Zuse design applies the principle of orthogonality to encapsulation:
every aspect of every exported item may be either hidden or revealed.
Specifically, Zuse supports three types of exported items: abstract,
semi-abstract, and concrete. These differ in the amount of implementation
information revealed to client modules: concrete items reveal all
representational details, semi-abstract items some, and abstract items
none. Exported items can also be paired with a protection clause that
restricts the ways in which they may be manipulated by particular clients.


The four translation system designs presented in the third part of the
thesis assure -- through the use of intermediate code module binding --
that the cost (in terms of execution-time and storage) of using an
abstract or semi-abstract item will be no greater than if the same item
had been concrete. In addition to performing the tasks of traditional
system link editors the sequential binder checks deferred context
conditions, performs inter-modular optimizations, and generates code for
deferred procedures. A deferred procedure is one for which the compiler is
unable to generate code because of references to imported abstract items.
Similarly, a deferred context condition is a static semantic check which
could not be performed at compile-time. The other translation systems
discussed in the thesis perform the same actions as the sequential binder,
but apply different techniques to improve performance: the distributed
binder distributes its actions over the sites of a distributed system such
as a network of workstations, the incremental binder inserts the code of
modified modules in-place in the executable program, and the hierarchical
binder binds collections of modules into libraries which themselves can
take part in later binds.


The sequential and distributed binders have been implemented, and their
performance is evaluated in the last part of the thesis. To examine the
behavior of the binders, a model of modular programs has been developed
which allows programs with widely differing qualities to be generated.
Results indicate that the distributed binder runs between $2$ and $3.5$
times as fast as the sequential binder; for some programs it is even
faster than traditional link editors.
--

Return to the comp.compilers page.
Search the comp.compilers archives again.