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.
Selection Committee 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.
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:
(for 2012) GPUVerify: a verifier for GPU kernels
GPU programming is supported by abstractions like CUDA and OpenCL. To gain the performance benefits of GPUs, these abstractions present a programming model that offers the potential for introducing subtle concurrency bugs like data races and barrier divergences. This paper presents the first GPU program verification method — GPUVerify. GPUVerify translates GPU programs into a sequential Boogie program that encodes the aspects of program behavior that give rise to data races and barrier divergence. Discharging proofs of the resulting programs requires appropriate inductive invariants and the paper identifies a collection of idiomatic invariants present in GPU programs that enable cost-effective verification. GPUVerify opened up a new problem space for verification research and the open-source tools developed on the project have been of use to practitioners and are recommended by major hardware manufacturers.
(for 2011) SugarJ: library-based syntactic language extensibility
SugarJ, already recognized as a distinguished paper at OOPSLA back in 2011, is a highly influential work on library-based syntactic language extensibility. This paper introduced the notion of “sugar libraries” for syntactically extending a language within the language. Unlike meta-programming/macro systems that typically rely on a pre-processor built on top of an existing language, syntactic extensions in SugarJ are built in the language. As a consequence, SugarJ has better composability properties than macro systems. Beyond making valuable theoretical contributions, SugarJ is available online and has been incorporated into Eclipse.
(for 2010) The spoofax language workbench: rules for declarative specification of languages and IDEs
Spoofax is a platform for developing textual domain-specific languages. It is a comprehensive environment that includes the tools to specify new languages, produces language processing tools such as type checkers, compilers, and interpreters, and support for integration in leading IDEs. Spoofax is used in industry and research, e.g., to develop WebDSL - a language that is one of the underpinnings of the researchr system used for many conference websites. Spoofax is rooted in a long line of research going back to the ASF+SDF MetaEnvironment, the SDF2 syntax definition formalism, and the Stratego transformation language. Spoofax is the basis for a line of further research in declarative language definition. This paper is the main scientific publication describing the entire environment in its 1.0 release and documenting the requirements and architecture for a language workbench.
(for 2009) Flapjax: a programming language for Ajax applications
(for 2008) jStar: towards practical verification for Java
The jStar paper is notable for introducing an approach to specifying OO design patterns that has since become standard and is used in modern tools such as VeriFast. The approach is amenable to automation and extends to patterns such as Subject-Observer, in which there is not a strict hierarchical relationship between objects.
The paper also describes a fully automated verification approach that required no proof hints within methods, inspiring the development of a number of later verification tools for separation logic.
(for 2007) Statistically rigorous Java performance evaluation
The paper by Georges et al. has been widely influential in Java performance evaluation. Before this paper, Java performance evaluation methodologies had varied widely, leading to difficulty in comparisons and often misleading conclusions. The authors survey several past studies, carefully discuss discrepancies in experimental and reporting methodologies, and expose the pitfalls of benchmarking approaches. The fundamental problem is that without an appropriate statistical analysis, it is difficult to tell whether reported measurements in the literature reflect significant distinctions or just random fluctuations. The paper proposes a statistically rigorous approach for experimental measurements in the Java setting, ways to mitigate uncertainty, and even new reporting techniques. The paper also introduced JavaStats, publicly available software that monitors the variability in measurements to determine how many measurements will be needed in all to reach a desired level of statistical confidence.
(for 2006) The DaCapo benchmarks: Java benchmarking development and analysis
The DaCapo benchmarks have become the de facto standard Java benchmarking suite, quickly replacing older suites, such as the SPEC JVM benchmarks. This paper describes principles for the selection and application of benchmarks for modern applications languages, and realizes those principles by proposing a set of client-side Java benchmarks based on real open source programs. The benchmarks were a notable improvement over previous benchmarks such as SPEC Java, for example because they more comprehensively test aspects of the Java virtual machine and memory management system. The paper puts forward a compelling model for benchmark selection and evaluation methodologies, and discusses in detail the experimental evaluation intricacies of the Java setting. The paper also introduces new metrics and contains detailed measurements of program behavior. The DaCapo paper has set a standard that substantially raised the level of Java experiments in the overall literature of the past decade. Since the paper’s publication, its methodological guidance and benchmarks have been widely adopted in research on language implementation techniques ranging from optimization to memory management, resulting in a significant impact on the quality of research in the field.
(for 2005) X10: An Object-Oriented Approach to Non-Uniform Cluster Computing
This paper presents X10, an object-oriented programming language based on the Java language and extended to make parallel programming effective and convenient for high-performance and high-productivity programming of non-uniform cluster computing systems — that is, computing systems in which both processor resources and memory resources are distributed. X10 highlights the explicit reification of locality in the form of places; supports explicitly controlled distribution and parallel processing of arrays; and allows the use of either lock-free synchronization using atomic blocks or explicit barrier synchronization using a novel clock mechanism. Although variants of some of these mechanisms had been explored in other language designs, X10 brought modern programming facilities to the scientific computing community by synthesizing a particularly useful combination of facilities within the Java language framework.
(for 2004) Mirrors: Design Principles for Meta-level Facilities of Object-Oriented Programming Languages
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.
(for 2003) Language Support for Lightweight Transactions
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.
(for 2001) Multitasking without compromise: a virtual machine evolution
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.
(for 1998) Ownership Types for Flexible Alias Protection
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.
(for 1997) Call Graph Construction in Object-Oriented Languages
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.