Most Influential OOPSLA Paper Award

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 current SIGPLAN Chair, ex officio,
  • a member of the SIGPLAN EC appointed as committee Chair by the SIGPLAN Chair,
  • the General Chair and Program Chair for OOPSLA N-10,
  • the General Chair and Program Chair for OOPSLA N-1, and
  • a member of the SIGPLAN EC appointed by the committee Chair.

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:


2023 Leo Meyerovich and Ariel Rabkin

(for 2013) Empirical analysis of programming language adoption


Some programming languages become wildly popular while others fade away. This paper seeks to answer why, by performing an empirical study spanning hundreds of thousands of open-source software projects and interviews with thousands of programmers. The methodology used in the paper is thorough, and the paper provides insights of interest to the broader Programming Languages community. Overall, this paper is a role model for large-scale empirical studies of programming languages, making it worthy of the OOPSLA 2013 Most Influential Paper Award.

2022 Adam Betts, Nathan Chong, Alastair Donaldson, Shaz Qadeer and Paul Thomson

(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.

2021 Sebastian Erdweg, Tillmann Rendel, Christian Kästner, Klaus Ostermann

(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.

2020 Lennart C.L. Kats, Eelco Visser

(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.

2019 Leo A. Meyerovich, Arjun Guha, Jacob Baskin, Gregory H. Cooper, Michael Greenberg, Aleks Bromfield, Shriram Krishnamurthi

(for 2009) Flapjax: a programming language for Ajax applications


Flapjax reimagines how to program client-based web applications by using abstractions dedicated to facilitating communication intensive applications with interactive interfaces. There are two central such abstractions in Flapjax, which were adopted from functional reactive programming: Event streams and so-called behaviors, with the latter modeling computations that bring themselves automatically up-to-date whenever data and computations they depend on change. This lets callbacks that are typically used in applications with interactive interfaces disappear from their designs … and with them also the hell of complexity they cause. Flapjax seamlessly builds on top of JavaScript without requiring a dedicated runtime and thus interoperates with existing applications written in JavaScript. This design choice lowers the barrier to entry and makes the language approachable to novice users. In terms of modern usage, the reactive style and event stream abstraction advocated by Flapjax have been adopted widely, both in mobile apps and on the web. Moreover, recent research has shown that beyond interactivity, behavior abstractions also facilitate correct-by-design distributed applications in presence of concurrency as well as crash and communication faults.

2018 Dino Distefano, Matthew Parkinson

(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.

2017 Andy Georges, Dries Buytaert, Lieven Eeckhout

(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.

2016 Stephen M. Blackburn, Robin Garner, Chris Hoffmann, Asjad M. Khan, Kathryn S. McKinley, Rotem Bentzur, Amer Diwan, Daniel Feinberg, Daniel Frampton, Samuel Z. Guyer, Martin Hirzel, Antony Hosking, Maria Jump, Han Lee, J. Eliot B. Moss, Aashish Phansalkar, Darko Stefanović, Thomas VanDrunen, Daniel von Dincklage, Ben Wiedermann

(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.

2015 Philippe Charles, Christian Grothoff, Vijay Saraswat, Christopher Donawa, Allan Kielstra, Kemal Ebcioglu, Christoph von Praun, and Vivek Sarkar

(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.

2014 Gilad Bracha and David Ungar

(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.

2013 Tim Harris and Keir Fraser

(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.

2012 Emery Berger, Benjamin G. Zorn, and Kathryn S. McKinley

(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.

2011 Grzegorz Czajkowski, Laurent Daynés

(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.

2010 Matthew Arnold, Stephen Fink, David Grove, Michael Hind, Peter F. Sweeney

(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.

2009 Bowen Alpern, C. R. Attanasio, Anthony Cocchi, Derek Lieber, Stephen Smith, Ton Ngo, John J. Barton, Susan Flynn Hummel, Janice C. Shepherd, and Mark Mergen

(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.

2008 David G. Clarke, John M. Potter, and James Noble

(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.

2007 David Grove, Greg DeFouw, Jeffrey Dean, and Craig Chambers

(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.