In this dissertation, we show how a relatively simple and extremely fast interprocedural optimization algorithm can be used to optimize many of the expensive features of statically typed, object-oriented languages --- in particular, C++ and Java. We present a new program analysis algorithm, Rapid Type Analysis, and show that it is fast both in theory and in practice, and significantly out-performs other "fast" algorithms for virtual function call resolution. We present optimization algorithms for the resolution of virtual function calls, conversion of virtual inheritance to direct inheritance, elimination of dynamic casts and dynamic type checks, and removal of object synchronization. These algorithms are all presented within a common framework that allows them to be driven by the information collected by Rapid Type Analysis, or by some other type analysis algorithm. Collectively, the optimizations in this dissertation free the programmer from having to sacrifice modularity and extensibility for performance. Instead, the programmer can freely make use of the most powerful features of object-oriented programming, since the optimizer will remove unnecessary extensibility from the program.

This paper suggests virtual types for Java, a language mechanism which subsumes parameterized classes, while also integrating more naturally with Java's object model. The same basic mechanism is also known as virtual patterns in Beta and as generics in Ada95. We discuss various issues in the Java type system, issues with inheritance and genericity in general, and give a specific suggestion as to how virtual types should be integrated into Java. Finally we describe how to make an e#cient implementation of virtual types based only upon the existing Java virtual machine. 1 Introduction Java is a new programming language which is interesting for many reasons. First of all, it is not the result of a language-research project in the traditional academic sense. Java is the result of engineering work, assembling many useful features developed for other programming languages, most visibly language features of Simula [6], Objective C [24] and C+ + [8]. In fact, it has been an expressed goal i...

this article, we propose a treatment of environments and the mechanism by which they are reified and manipulated, that addresses these concerns. The language described below (Rascal) permits environments to be reified into data structures, and data structures to be reflected into environments, but gives users great flexibility to constrain the extent and scope of these processes. We argue that the techniques and operators developed define a cohesive basis for building largescale modular systems using reflective programming techniques.

The efficient execution of Java programs presents a challenge to hardware and software designers alike. The difficulty however lies with the Javabytecodes. Their model of a simplistic, platform-independent stack machine is well-suited for portability, though at the expense of execution speed. Various approaches are being proposed to increase the speed of Javabytecode programs, including: (1) on-the-fly compilation to native code (also known as JIT or "just-in-time" compilation); (2) traditional ("ahead-of-time") compilation of bytecodes to some higher-level intermediate form and then to native code; and (3) translation of bytecodes to a higher-level language and then use of an existing compiler to produce native code. Speedups on the order of 50 over standard bytecode interpretation have been claimed.

The efficiency of dynamic dispatch is a major impediment to the adoption of multi-methods in object languages. In this paper, we propose a simple multi-method dispatch scheme based on compressed dispatch tables. This scheme is applicable to most existing object languages, and guarantees that dynamic dispatch is performed in constant time, a major requirement for some languages and applications. We provide efficient algorithms to build the compressed dispatch tables, and demonstrate the effectiveness of our scheme by real measurements performed on a large object-oriented application. Finally, we relate our scheme to existing techniques, including a detailed comparison with a recent proposal.

The paper discusses the main aspects of a parallel debugger for the parallel object-oriented language pSather. PSather provides for a single shared-address space and for multiple threads per processor. Threads can arbitrarily migrate between processors. The debugger supports cyclic debugging which is a standard and quite effective technique for sequential programs. To address nondeterminism, deterministic replay is provided. For that reason, one program run is traced. The debugger uses these traces to repeatedly and identically reexecute the recorded program run. An efficient trace and replay scheme that is in particular suited for pSather and that reduces program perturbation and trace file length is presented. Furthermore, breakpoints and single-stepping for such a debugger using deterministic replay are discussed. 1 Introduction Debugging of sequential programs seems to be well understood. The standard technique is testing until an error manifests as a program failure and then to l...

In light of the recent modifications to the de facto standard implementation Objective-C language by Apple Inc., the GNU Objective-C runtime lacks a number of features that are desirable for a modern implementation. This paper presents a metaobject protocol flexible enough to implement Objective-C and other languages of interest. It also presents an implementation of this model in the form of a new Objective-C runtime library which supports all of the new features of Objective-C 2.0 as well as safe inline caching, mixins, prototype-based object orientation, transparent support for other languages—including those with a prototype-based object model—and a small, maintainable code base.