Presented annually to the author(s) of a paper presented at the OOPSLA held 10 years prior to the award year. The award includes a prize of $1,000 to be split among the authors of the winning paper. The papers are judged by their influence over the past decade.
The award given in year N is for the most influential paper presented at the conference held in year N-10. The selection committee consists of the following members:
The SIGPLAN Chair shall adjudicate conflicts of interest, appointing substitutes to the committee as necessary. The Most Influential OOPSLA Paper Award instituted in
To cover the years from the inception of OOPSLA (1986) to 1996, the OOPSLA steering committee formed a committee to select the three most influential OOPSLA papers that were presented during that time period. The three most influential OOPSLA papers from 1986-1996:
Bracha and Ungar’s “Mirrors” paper describes a novel approach to reflection in object-oriented API design, in which reflection is broken off into a modular meta-level capability instead of being baked into the functionality of base-level classes. Mirrors have had a strong influence on subsequent designs for reflection capabilities, extensibility in support of domain-specific languages, and metacircular virtual machines. They are at the foundation of reflection libraries in Scala and Dart, as well as the Java Debugger Interface (JDI) design, which offers reflective control of Java VMs. As for the paper itself, the committee felt it was a prime representative of the strengths of OOPSLA in delivering important and influential ideas with clarity and simplicity.
In this paper, Harris and Fraser demonstrated how to leverage the memory safety and automatic memory management features of a concurrent object-oriented language to build a Software Transactional Memory (STM) abstraction that is tightly integrated with the language. In particular, their core contribution was to show how conditional critical regions (CCRs) could provide a higher-level language interface to STM, rather than requiring manipulation of the STM through low-level operations. In so doing, they also developed a more efficient implementation infrastructure for CCRs than was available previously, and their implementation was pay-as-you-go in the sense of not imposing high overhead on those parts of a program where CCRs are not required. Coming ten years after STM was first proposed, this work opened the door for a decade of research in languages and architecture for concurrency control.
(for 2002) Reconsidering Custom Memory Allocation
Custom memory management is often used in systems software for the purpose of decreasing the cost of allocation and tightly controlling memory footprint of the software. Until 2002, it was taken for granted that application-specific memory allocators were superior to general purpose libraries. Berger, Zorn and McKinley’s paper demonstrated through a rigorous empirical study that this assumption is not well-founded, and gave insights into the reasons why general purpose allocators can outperform handcrafted ones. The paper also stands out for the quality of its empirical methodology.
The Multitasking Virtual Machine (MVM) described in this paper was the first usable and complete Java VM (JVM) to support safe, secure, and scalable multitasking. Safety is achieved by strict but lightweight isolation of applications from one another. Security comes via resource control mechanisms that prevent some denial-of-service attacks. Scalability derives from sharing as much of the run-time system as possible among applications and replicating everything else. MVM has since had significant influence on the design of other VMs, including Google’s Dalvik JVM for mobile platforms. MVM was the setting for subsequent work resulting in the Isolates programming interface. Isolation is the basis for many infrastructures for both mobile devices and backend Clouds. Indeed, the recently announced Dart language for structured Web programming relies on Isolates as its foundation for concurrent programming.
(for 2000) Adaptive Optimization in the Jalapeño JVM
The 2000 OOPSLA paper “Adaptive Optimization in the Jalapeño JVM” describes the architecture of adaptive optimization in what is now known as the Jikes RVM (Research Virtual Machine), continuing a line of research in dynamic adaptive optimizing compilers including Self and Animorphic (later HotSpot). The novelty of this paper was its use of continuous sampling to obtain execution statistics for optimized as well as unoptimized code. Also, because Jikes RVM is written entirely in Java, the techniques apply not only to the application but also to the VM and its components. Follow-on work has used, refined, and extended upon this adaptive optimization infrastructure. The paper has inspired significant further innovation in dynamic profiling and remains a primary reference for its exposition of the basic ingredients of adaptive optimization for modern VM-based languages.
(for 1999) Implementing Jalapeño in Java,
The 1999 OOPSLA paper “Implementing Jalapeño in Java” describes how the authors implemented a Java Virtual Machine in the Java language. This system, which was eventually renamed the Jikes RVM and released to the public, enabled a whole range of academic and industrial research in virtual machines that would have been difficult or impossible otherwise. To this day, researchers successfully use the Jikes RVM as a platform for new investigations.
In their 1998 OOPSLA paper, “Ownership Types for Flexible Protection,” David Clark, John Potter, and James Nobel introduced the notion of “ownership types” to control inter-object aliasing statically, making it easier to reason about the dynamic topology of an object-oriented program. This work is part of the broader trend of trying to handle issues of isolation and modularity while retaining expressiveness.
In their 1997 OOPSLA paper “Call Graph Construction in Object-Oriented Languages,” David Grove, Greg DeFouw, Jeffrey Dean, and Craig Chambers studied the existing algorithms for call-graph construction in object-oriented languages and brought them together into a unified framework. This framework is both theoretical, allowing the authors to compare the precision of the different algorithms, and also practical in that they built a single parameterized implementation of all of the algorithms. This implementation allowed them to conduct a thorough empirical evaluation of the algorithms, which had not been previously possible because the algorithms had been implemented separately and applied to different programs. In the process, the authors discovered and evaluated a few new variations suggested by their framework. This kind of consolidation paper is important for moving the field forward since it provides theoretical models to build on and performance evaluations as benchmarks. It has served as a model for later work of this kind.