NOTE: This document is still under construction! 1

Optimizing implementations for object-oriented languages rely on aggressive inlining to achieve good performance. Sometimes the compiler is over-eager in its quest for good performance, however, and inlines too many methods that merely increase compile time and consume extra compiled code space with little benefit in run-time performance. We have designed and implemented a new approach to inlining decision making in which the compiler performs inlining experimentally and records the results in a database that can be consulted to guide future inlining decisions of the same routine at call sites that have similar static information. Central to our approach is a new technique, called type group analysis, that calculates how much of the static information available at a call site was profitably used during inlining. The results of type group analysis enable the compiler to compute a generalization of the actual static information for a particular experiment, significantly increasing reuse ...

Modularization Mechanisms such as mix-ins, units, open classes, hyper-slices, adaptive methods, roles, composition filters, pointcut-advice, and intertype declarations have shown significant potential. They provide software engineers with new capabilities to modularize concerns that were hard to separate previously. Support for these modularization mechanisms have so far been largely limited to high-level languages and their compilers. Recent research results have shown that deeper support, e.g. in virtual machines and intermediate languages, have far-reaching impacts. In particular, more optimization opportunities open up. Development processes such as incremental compilation, debugging, etc are radically simplified. Moreover, dynamic support becomes possible without compromising on efficiency. To that end, the objective of this workshop, first in the series, is to generate interest in this topic, to frame and refine research problem formulations, and to identify and encourage the pursuit of promising opportunities and approaches. We invite novel insights from within the programming language, compilers, virtual machine community and elsewhere.

SELF's debugging system provides complete source-level debugging (expected behavior) with globally optimized code. It shields the debugger from optimizations performed by the compiler by dynamically deoptimizing code on demand. Deoptimization only affects the procedure activations that are actively being debugged; all other code runs at full speed. Deoptimization requires the compiler to supply debugging information at discrete interrupt points; the compiler can still perform extensive optimizations between interrupt points without affecting debuggability. At the same time, the inability to interrupt between interrupt points is invisible to the user. Our debugging system also handles programming changes during debugging. Again, the system provides expected behavior: it is possible to change a running program and immediately observe the effects of the change. Dynamic deoptimization transforms old compiled code (which may contain inlined copies of the old version of the changed procedure) into new versions reflecting the current source-level state. To the best of our knowledge, SELF is the first practical system providing full expected behavior with globally optimized code.