We introduce a class of program editors that present a program using a rich set of transformations; we call these kinds of editors composable presentation editors. Proper use of these kinds of editors appears to lead to more expressive programs-programs whose structure are aligned with the problem they are trying to solve. By default, the composable presentation editor presents program elements textually as concrete syntax and enables typical editor commands on the program. Metadata on program elements control how the transformations are applied. Customized metadata can re-order, pictorialize, collapse, duplicate, or expand the displayed form of program elements and can additionally alter the available editor commands. We have developed a set of presentation techniques to be used by presentation designers (i.e., the programmers who design how a program is presented in the editor. These techniques relate to well-understood programming language design, editor design, and programming best-practices techniques including scoping, higher order functions, refactoring, prettyprinting, naming conventions, syntax highlighting, and text hovers. We introduce two implementations of composable presentation editors and a number of examples showing how programs can be made more expressive when presentation techniques are properly used. The first implementation is the ETMOP, an open editor, where a metaobject protocol is provided that allows language and editor designers to customize the way program elements are displayed. These customizations are called presenta- tion extensions and the corresponding presentation extension protocol acts in a way similar to the way that syntax macros extend the syntax of a language. The second implementation is Embedded CAL, a closed editor that uses these presentation techniques to embed one language (CAL) inside a host language (Java) through the use of presentation techniques, without changing the syntax or compiler of either language.

The object-oriented community is paying increasing attention to techniques for object instance encapsulation and alias protection. Formal techniques for modular verification of programs at the level of objects are being developed hand in hand with type systems and static analysis techniques for restricting the structure of runtime object graphs. Ownership type systems have provided a sound basis for such structural restrictions by being able to statically represent an extensible object ownership hierarchy. However, such structural restrictions may potentially have limitations on cases when more flexible reference structures are desired. In this thesis, we present a different encapsulation technique, called Effect Encapsulation, which confines side effects rather than object references. With relaxed restriction on reference structure, it is able to express certain common object-oriented patterns which cannot be expressed in Ownership Types. From this basis, we also describe a model of Object Validity --- a framework for reasoning about object invariants. Such a framework can track the effect and dependency of method calls on object invariants within an ownership-based type system, even in the presence of re-entrant calls. Moreover, we present an access control technique for protecting object instances. Combined with context variance, the resulting type system allows for a more flexible and useful access control policy, hence is capable of expressing more object-oriented patterns.

Bibliography: leaves 215-229. / viii, 229 leaves ; 30 cm. / Title page, contents and abstract only. The complete thesis in print form is available from the University Library. / This thesis presents a new method for performing incremental code generation in a distributed integrated programming environment. A prototype implementation of such an incremental code generator is also described. The study derives a new retargetable incremental instruction algorithm from a non-incremental instruction selection technique in the framework of a precise model of the underlying program representation. The resulting algorithm incrementally regenerates locally optimal object code after the replacement of a subtree in an abstract syntax tree program representation. / Thesis (Ph.D.)--University of Adelaide, Dept. of Computer Science, 1996

Thesis (M.S.)--Rochester Institute of Technology, 1989. / Includes bibliographical references.

Thesis (Ph. D.)--University of Adelaide, 1985. / Includes bibliographical references (leaves [238]-244).

Thesis (M.S.)--Ohio University, March, 2000. / Title from PDF t.p.

Thesis (Ph.D.) in Spatial Information Science and Engineering--University of Maine, 2007. / Includes vita. Includes bibliographical references (leaves 145-153).

Thesis (M.S.)--Virginia Polytechnic Institute and State University, 1990. / Vita. Abstract. Includes bibliographical references (leaves 171-172). Also available via the Internet.

Thesis (M.Comp.Sc.)--University of Wollongong, 2006. / Typescript. Includes bibliographical references: leaf 98-102.

Thesis (Ph.D.). / Written for the School of Computer Science. Title from title page of PDF (viewed 2008/02/12). Includes bibliographical references.