2014

• David Greenaway,Japheth Lim,June Andronick,Gerwin Klein,Don't sweat the small stuff: formal verification of C code without the pain.
• Jade Alglave,Luc Maranget,Michael Tautschnig,Herding cats: modelling, simulation, testing, and data-mining for weak memory.
• Sanket Tavarageri,Sriram Krishnamoorthy,P. Sadayappan,Compiler-assisted detection of transient memory errors.
• Loris D'Antoni,Margus Veanes,Benjamin Livshits,David Molnar,Fast: a transducer-based language for tree manipulation.
• Pallavi Maiya,Aditya Kanade,Rupak Majumdar,Race detection for Android applications.
• Suresh Jagannathan,Gustavo Petri,Jan Vitek,David Pichardie,Vincent Laporte,Atomicity refinement for verified compilation.
• Yaniv David,Eran Yahav,Tracelet-based code search in executables.
• Yufei Cai,Paolo G. Giarrusso,Tillmann Rendel,Klaus Ostermann,A theory of changes for higher-order languages: incrementalizing λ-calculi by static differentiation.
• Lindsey Kuper,Aaron Todd,Sam Tobin-Hochstadt,Ryan R. Newton,Taming the parallel effect zoo: extensible deterministic parallelism with LVish.
• Li Lu,Weixing Ji,Michael L. Scott,Dynamic enforcement of determinism in a parallel scripting language.
• Hakjoo Oh,Wonchan Lee,Kihong Heo,Hongseok Yang,Kwangkeun Yi,Selective context-sensitivity guided by impact pre-analysis.
• Phitchaya Mangpo Phothilimthana,Tikhon Jelvis,Rohin Shah,Nishant Totla,Sarah Chasins,Rastislav Bodík,Chlorophyll: synthesis-aided compiler for low-power spatial architectures.
• Daniel Perelman,Sumit Gulwani,Dan Grossman,Peter Provost,Test-driven synthesis.
• Daniel Ricketts,Valentin Robert,Dongseok Jang,Zachary Tatlock,Sorin Lerner,Automating formal proofs for reactive systems.
• Marcelo Sousa,Isil Dillig,Dimitrios Vytiniotis,Thomas Dillig,Christos Gkantsidis,Consolidation of queries with user-defined functions.
• Min Aung,Susan Horwitz,Richard Joiner,Thomas W. Reps,Specialization slicing.
• Mateus Borges,Antonio Filieri,Marcelo d'Amorim,Corina S. Pasareanu,Willem Visser,Compositional solution space quantification for probabilistic software analysis.
• Rishi Surendran,Raghavan Raman,Swarat Chaudhuri,John M. Mellor-Crummey,Vivek Sarkar,Test-driven repair of data races in structured parallel programs.
• Xin Zhang,Ravi Mangal,Radu Grigore,Mayur Naik,Hongseok Yang,On abstraction refinement for program analyses in Datalog.
• Ben Greenman,Fabian Muehlboeck,Ross Tate,Getting F-bounded polymorphism into shape.
• Vu Le,Mehrdad Afshari,Zhendong Su,Compiler validation via equivalence modulo inputs.
• Eric Schkufza,Rahul Sharma,Alex Aiken,Stochastic optimization of floating-point programs with tunable precision.
• Edward Z. Yang,David Mazières,Dynamic space limits for Haskell.
• Fan Long,Stelios Sidiroglou-Douskos,Martin C. Rinard,Automatic runtime error repair and containment via recovery shepherding.
• Thomas Ball,Nikolaj Bjørner,Aaron Gember,Shachar Itzhaky,Aleksandr Karbyshev,Mooly Sagiv,Michael Schapira,Asaf Valadarsky,VeriCon: towards verifying controller programs in software-defined networks.
• Edgar Pek,Xiaokang Qiu,P. Madhusudan,Natural proofs for data structure manipulation in C using separation logic.
• Srinath Sridharan,Gagan Gupta,Gurindar S. Sohi,Adaptive, efficient, parallel execution of parallel programs.
• Dimitar Dimitrov,Veselin Raychev,Martin T. Vechev,Eric Koskinen,Commutativity race detection.
• Quentin Carbonneaux,Jan Hoffmann,Tahina Ramananandro,Zhong Shao,End-to-end verification of stack-space bounds for C programs.
• John Vilk,Emery D. Berger,Doppio: breaking the browser language barrier.
• Justin Pombrio,Shriram Krishnamurthi,Resugaring: lifting evaluation sequences through syntactic sugar.
• Matthew A. Hammer,Yit Phang Khoo,Michael Hicks,Jeffrey S. Foster,Adapton: composable, demand-driven incremental computation.
• Vu Le,Sumit Gulwani,FlashExtract: a framework for data extraction by examples.
• Zachary DeVito,Daniel Ritchie,Matthew Fisher,Alex Aiken,Pat Hanrahan,First-class runtime generation of high-performance types using exotypes.
• Sven Stork,Karl Naden,Joshua Sunshine,Manuel Mohr,Alcides Fonseca,Paulo Marques,Jonathan Aldrich,Æminium: a permission based concurrent-by-default programming language approach.
• Loi Luu,Shweta Shinde,Prateek Saxena,Brian Demsky,A model counter for constraints over unbounded strings.
• Wonsun Ahn,Jiho Choi,Thomas Shull,María Jesús Garzarán,Josep Torrellas,Improving JavaScript performance by deconstructing the type system.
• Tiark Rompf,Arvind K. Sujeeth,Kevin J. Brown,HyoukJoong Lee,Hassan Chafi,Kunle Olukotun,Surgical precision JIT compilers.
• Yannis Smaragdakis,George Kastrinis,George Balatsouras,Introspective analysis: context-sensitivity, across the board.
• Francesco Logozzo,Shuvendu K. Lahiri,Manuel Fähndrich,Sam Blackshear,Verification modulo versions: towards usable verification.
• Xiao Xiao,Qirun Zhang,Jinguo Zhou,Charles Zhang,Persistent pointer information.
• Swarnendu Biswas,Jipeng Huang,Aritra Sengupta,Michael D. Bond,DoubleChecker: efficient sound and precise atomicity checking.
• Gagan Gupta,Srinath Sridharan,Gurindar S. Sohi,Globally precise-restartable execution of parallel programs.
• Chung-Kil Hur,Aditya V. Nori,Sriram K. Rajamani,Selva Samuel,Slicing probabilistic programs.
• Jeff Huang,Patrick O'Neil Meredith,Grigore Rosu,Maximal sound predictive race detection with control flow abstraction.
• Veselin Raychev,Martin T. Vechev,Eran Yahav,Code completion with statistical language models.
• Steven Arzt,Siegfried Rasthofer,Christian Fritz,Eric Bodden,Alexandre Bartel,Jacques Klein,Yves Le Traon,Damien Octeau,Patrick McDaniel,FlowDroid: precise context, flow, field, object-sensitive and lifecycle-aware taint analysis for Android apps.
• Chun-Hung Hsiao,Cristiano Pereira,Jie Yu,Gilles Pokam,Satish Narayanasamy,Peter M. Chen,Ziyun Kong,Jason Flinn,Race detection for event-driven mobile applications.
• Emina Torlak,Rastislav Bodík,A lightweight symbolic virtual machine for solver-aided host languages.
• Kevin Stock,Martin Kong,Tobias Grosser,Louis-Noël Pouchet,Fabrice Rastello,J. Ramanujam,P. Sadayappan,A framework for enhancing data reuse via associative reordering.
• Subrata Mitra,Ignacio Laguna,Dong H. Ahn,Saurabh Bagchi,Martin Schulz,Todd Gamblin,Accurate application progress analysis for large-scale parallel debugging.
• Reinhard von Hanxleden,Björn Duderstadt,Christian Motika,Steven Smyth,Michael Mendler,Joaquin Aguado,Stephen Mercer,Owen O'Brien,SCCharts: sequentially constructive statecharts for safety-critical applications: HW/SW-synthesis for a conservative extension of synchronous statecharts.
• Xin Zhang,Ravi Mangal,Mayur Naik,Hongseok Yang,Hybrid top-down and bottom-up interprocedural analysis.
• Axel Simon,Optimal inference of fields in row-polymorphic records.
• Adrian Sampson,Pavel Panchekha,Todd Mytkowicz,Kathryn S. McKinley,Dan Grossman,Luis Ceze,Expressing and verifying probabilistic assertions.
• Ben Niu,Gang Tan,Modular control-flow integrity.

2013

• Xiaokang Qiu,Pranav Garg,Andrei Stefanescu,Parthasarathy Madhusudan,Natural proofs for structure, data, and separation.
• Tiejun Gao,Karin Strauss,Stephen M. Blackburn,Kathryn S. McKinley,Doug Burger,James R. Larus,Using managed runtime systems to tolerate holes in wearable memories.
• Kalmer Apinis,Helmut Seidl,Vesal Vojdani,How to combine widening and narrowing for non-monotonic systems of equations.
• Sam Blackshear,Shuvendu K. Lahiri,Almost-correct specifications: a modular semantic framework for assigning confidence to warnings.
• Jonathan Lifflander,Sriram Krishnamoorthy,Laxmikant V. Kalé,Steal Tree: low-overhead tracing of work stealing schedulers.
• Guy Golan-Gueta,G. Ramalingam,Mooly Sagiv,Eran Yahav,Concurrent libraries with foresight.
• Yang Chen,Alex Groce,Chaoqiang Zhang,Weng-Keen Wong,Xiaoli Fern,Eric Eide,John Regehr,Taming compiler fuzzers.
• Khaled Elwazeer,Kapil Anand,Aparna Kotha,Matthew Smithson,Rajeev Barua,Scalable variable and data type detection in a binary rewriter.
• Nick P. Johnson,Taewook Oh,Ayal Zaks,David I. August,Fast condensation of the program dependence graph.
• Evan Czaplicki,Stephen Chong,Asynchronous functional reactive programming for GUIs.
• Zachary DeVito,James Hegarty,Alex Aiken,Pat Hanrahan,Jan Vitek,Terra: a multi-stage language for high-performance computing.
• Rishabh Singh,Sumit Gulwani,Armando Solar-Lezama,Automated feedback generation for introductory programming assignments.
• Eric Bodden,Társis Tolêdo,Márcio Ribeiro,Claus Brabrand,Paulo Borba,Mira Mezini,SPLLIFT: statically analyzing software product lines in minutes instead of years.
• Jeff Huang,Charles Zhang,Julian Dolby,CLAP: recording local executions to reproduce concurrency failures.
• Tayfun Elmas,Jacob Burnim,George C. Necula,Koushik Sen,CONCURRIT: a domain specific language for reproducing concurrency bugs.
• Max Schäfer,Manu Sridharan,Julian Dolby,Frank Tip,Dynamic determinacy analysis.
• Martin Kong,Richard Veras,Kevin Stock,Franz Franchetti,Louis-Noël Pouchet,P. Sadayappan,When polyhedral transformations meet SIMD code generation.
• Jiajia Li,Guangming Tan,Mingyu Chen,Ninghui Sun,SMAT: an input adaptive auto-tuner for sparse matrix-vector multiplication.
• Sebastian Burckhardt,Manuel Fähndrich,Peli de Halleux,Sean McDirmid,Michal Moskal,Nikolai Tillmann,Jun Kato,It's alive! continuous feedback in UI programming.
• Xin Zhang,Mayur Naik,Hongseok Yang,Finding optimum abstractions in parametric dataflow analysis.
• Nikhil Swamy,Joel Weinberger,Cole Schlesinger,Juan Chen,Benjamin Livshits,Verifying higher-order programs with the dijkstra monad.
• Robin Morisset,Pankaj Pawan,Francesco Zappa Nardelli,Compiler testing via a theory of sound optimisations in the C11/C++11 memory model.
• Hongtao Yu,Hou-Jen Ko,Zhiyuan Li,General data structure expansion for multi-threading.
• Byron Cook,Eric Koskinen,Reasoning about nondeterminism in programs.
• Tihomir Gvero,Viktor Kuncak,Ivan Kuraj,Ruzica Piskac,Complete completion using types and weights.
• Sam Blackshear,Bor-Yuh Evan Chang,Manu Sridharan,Thresher: precise refutations for heap reachability.
• Wei-Lun Hung,Vijay K. Garg,AutoSynch: an automatic-signal monitor based on predicate tagging.
• Qirun Zhang,Michael R. Lyu,Hao Yuan,Zhendong Su,Fast algorithms for Dyck-CFL-reachability with applications to alias analysis.
• Thomas Arthur Leck Sewell,Magnus O. Myreen,Gerwin Klein,Translation validation for a verified OS kernel.
• Hongjin Liang,Xinyu Feng,Modular verification of linearizability with non-fixed linearization points.
• Sriram Sankaranarayanan,Aleksandar Chakarov,Sumit Gulwani,Static analysis for probabilistic programs: inferring whole program properties from finitely many paths.
• Colin S. Gordon,Michael D. Ernst,Dan Grossman,Rely-guarantee references for refinement types over aliased mutable data.
• Nachshon Cohen,Erez Petrank,Limitations of partial compaction: towards practical bounds.
• Tony Nowatzki,Michael Sartin-Tarm,Lorenzo De Carli,Karthikeyan Sankaralingam,Cristian Estan,Behnam Robatmili,A general constraint-centric scheduling framework for spatial architectures.
• Ankush Desai,Vivek Gupta,Ethan K. Jackson,Shaz Qadeer,Sriram K. Rajamani,Damien Zufferey,P: safe asynchronous event-driven programming.
• Alexander S. Green,Peter LeFanu Lumsdaine,Neil J. Ross,Peter Selinger,Benoît Valiron,Quipper: a scalable quantum programming language.
• Jonathan Ragan-Kelley,Connelly Barnes,Andrew Adams,Sylvain Paris,Frédo Durand,Saman P. Amarasinghe,Halide: a language and compiler for optimizing parallelism, locality, and recomputation in image processing pipelines.
• Jianzhou Zhao,Santosh Nagarakatte,Milo M. K. Martin,Steve Zdancewic,Formal verification of SSA-based optimizations for LLVM.
• Ilya Sergey,Dominique Devriese,Matthew Might,Jan Midtgaard,David Darais,Dave Clarke,Frank Piessens,Monadic abstract interpreters.
• Bharghava Rajaram,Vijay Nagarajan,Susmit Sarkar,Marco Elver,Fast RMWs for TSO: semantics and implementation.
• Ben Titzer,Harmonizing classes, functions, tuples, and type parameters in virgil iii.
• Alvin Cheung,Armando Solar-Lezama,Samuel Madden,Optimizing database-backed applications with query synthesis.
• George Kastrinis,Yannis Smaragdakis,Hybrid context-sensitivity for points-to analysis.
• Chinawat Isradisaikul,Andrew C. Myers,Reconciling exhaustive pattern matching with objects.
• Abhishek Udupa,Arun Raghavan,Jyotirmoy V. Deshmukh,Sela Mador-Haim,Milo M. K. Martin,Rajeev Alur,TRANSIT: specifying protocols with concolic snippets.
• Arjun Guha,Mark Reitblatt,Nate Foster,Machine-verified network controllers.

2012

• Bruno C. d. S. Oliveira,Tom Schrijvers,Wontae Choi,Wonchan Lee,Kwangkeun Yi,The implicit calculus: a new foundation for generic programming.
• Marc de Kruijf,Karthikeyan Sankaralingam,Somesh Jha,Static analysis and compiler design for idempotent processing.
• Mehrzad Samadi,Amir Hormati,Mojtaba Mehrara,Janghaeng Lee,Scott A. Mahlke,Adaptive input-aware compilation for graphics engines.
• Paul Gazzillo,Robert Grimm,SuperC: parsing all of C by taming the preprocessor.
• Patrice Godefroid,Ankur Taly,Automated synthesis of symbolic instruction encodings from I/O samples.
• Sergey Grebenshchikov,Nuno P. Lopes,Corneliu Popeea,Andrey Rybalchenko,Synthesizing software verifiers from proof rules.
• Jun Liu,Yuanrui Zhang,Ohyoung Jang,Wei Ding,Mahmut T. Kandemir,A compiler framework for extracting superword level parallelism.
• Min Feng,Rajiv Gupta,Iulian Neamtiu,Effective parallelization of loops in the presence of I/O operations.
• Rachid Guerraoui,Viktor Kuncak,Giuliano Losa,Speculative linearizability.
• Luke Cartey,Rune Lyngsø,Oege de Moor,Synthesising graphics card programs from DSLs.
• Michael Pradel,Thomas R. Gross,Fully automatic and precise detection of thread safety violations.
• Charisee Chiw,Gordon L. Kindlmann,John Reppy,Lamont Samuels,Nick Seltzer,Diderot: a parallel DSL for image analysis and visualization.
• Emilio Coppa,Camil Demetrescu,Irene Finocchi,Input-sensitive profiling.
• Justin Holewinski,Ragavendar Ramamurthi,Mahesh Ravishankar,Naznin Fauzia,Louis-Noël Pouchet,Atanas Rountev,P. Sadayappan,Dynamic trace-based analysis of vectorization potential of applications.
• Aaron Turon,Reagents: expressing and composing fine-grained concurrency.
• Jeffrey Fischer,Rupak Majumdar,Shahram Esmaeilsabzali,Engage: a deployment management system.
• Yong Hun Eom,Brian Demsky,Self-stabilizing Java.
• Dmitrijs Zaparanuks,Matthias Hauswirth,Algorithmic profiling.
• Volodymyr Kuznetsov,Johannes Kinder,Stefan Bucur,George Candea,Efficient state merging in symbolic execution.
• Michael Carbin,Deokhwan Kim,Sasa Misailovic,Martin C. Rinard,Proving acceptability properties of relaxed nondeterministic approximate programs.
• Danfeng Zhang,Aslan Askarov,Andrew C. Myers,Language-based control and mitigation of timing channels.
• Omer Tripp,Roman Manevich,John Field,Mooly Sagiv,JANUS: exploiting parallelism via hindsight.
• Florian Benz,Andreas Hildebrandt,Sebastian Hack,A dynamic program analysis to find floating-point accuracy problems.
• Hakjoo Oh,Kihong Heo,Wonchan Lee,Woosuk Lee,Kwangkeun Yi,Design and implementation of sparse global analyses for C-like languages.
• Peter Hawkins,Alex Aiken,Kathleen Fisher,Martin C. Rinard,Mooly Sagiv,Concurrent data representation synthesis.
• Jingyue Wu,Yang Tang,Gang Hu,Heming Cui,Junfeng Yang,Sound and precise analysis of parallel programs through schedule specialization.
• Feng Liu,Nayden Nedev,Nedyalko Prisadnikov,Martin T. Vechev,Eran Yahav,Dynamic synthesis for relaxed memory models.
• Brian Hackett,Shu-yu Guo,Fast and precise hybrid type inference for JavaScript.
• Alan Leung,Manish Gupta,Yuvraj Agarwal,Rajesh Gupta,Ranjit Jhala,Sorin Lerner,Verifying GPU kernels by test amplification.
• David F. Bacon,Perry Cheng,Sunil Shukla,And then there were none: a stall-free real-time garbage collector for reconfigurable hardware.
• Yan Chen,Joshua Dunfield,Umut A. Acar,Type-directed automatic incrementalization.
• Cosmin E. Oancea,Lawrence Rauchwerger,Logical inference techniques for loop parallelization.
• Susmit Sarkar,Kayvan Memarian,Scott Owens,Mark Batty,Peter Sewell,Luc Maranget,Jade Alglave,Derek Williams,Synchronising C/C++ and POWER.
• Ming Kawaguchi,Patrick Maxim Rondon,Alexander Bakst,Ranjit Jhala,Deterministic parallelism via liquid effects.
• Chun Chen,Polyhedra scanning revisited.
• Guoliang Jin,Linhai Song,Xiaoming Shi,Joel Scherpelz,Shan Lu,Understanding and detecting real-world performance bugs.
• Dongyoon Lee,Peter M. Chen,Jason Flinn,Satish Narayanasamy,Chimera: hybrid program analysis for determinism.
• Santosh Nagarakatte,Sebastian Burckhardt,Milo M. K. Martin,Madanlal Musuvathi,Multicore acceleration of priority-based schedulers for concurrency bug detection.
• Aws Albarghouthi,Rahul Kumar,Aditya V. Nori,Sriram K. Rajamani,Parallelizing top-down interprocedural analyses.
• Christophe Dubach,Perry Cheng,Rodric M. Rabbah,David F. Bacon,Stephen J. Fink,Compiling a high-level language for GPUs: (via language support for architectures and compilers).
• John Regehr,Yang Chen,Pascal Cuoq,Eric Eide,Chucky Ellison,Xuejun Yang,Test-case reduction for C compiler bugs.
• Arun Raman,Ayal Zaks,Jae W. Lee,David I. August,Parcae: a system for flexible parallel execution.
• Daniel Perelman,Sumit Gulwani,Thomas Ball,Dan Grossman,Type-directed completion of partial expressions.
• Isil Dillig,Thomas Dillig,Alex Aiken,Automated error diagnosis using abductive inference.
• Boris Petrov,Martin T. Vechev,Manu Sridharan,Julian Dolby,Race detection for web applications.
• Greg Morrisett,Gang Tan,Joseph Tassarotti,Jean-Baptiste Tristan,Edward Gan,RockSalt: better, faster, stronger SFI for the x86.
• Raghavan Raman,Jisheng Zhao,Vivek Sarkar,Martin T. Vechev,Eran Yahav,Scalable and precise dynamic datarace detection for structured parallelism.
• Nick P. Johnson,Hanjun Kim,Prakash Prabhu,Ayal Zaks,David I. August,Speculative separation for privatization and reductions.

2011

• Ross Tate,Alan Leung,Sorin Lerner,Taming wildcards in Java's type system.
• Suzette Person,Guowei Yang,Neha Rungta,Sarfraz Khurshid,Directed incremental symbolic execution.
• Na Meng,Miryung Kim,Kathryn S. McKinley,Systematic editing: generating program transformations from an example.
• Susmit Sarkar,Peter Sewell,Jade Alglave,Luc Maranget,Derek Williams,Understanding POWER multiprocessors.
• Guoqing (Harry) Xu,Michael D. Bond,Feng Qin,Atanas Rountev,LeakChaser: helping programmers narrow down causes of memory leaks.
• Xun Li,Mohit Tiwari,Jason Oberg,Vineeth Kashyap,Frederic T. Chong,Timothy Sherwood,Ben Hardekopf,Caisson: a hardware description language for secure information flow.
• Lukasz Ziarek,K. C. Sivaramakrishnan,Suresh Jagannathan,Composable asynchronous events.
• Saurabh Srivastava,Sumit Gulwani,Swarat Chaudhuri,Jeffrey S. Foster,Path-based inductive synthesis for program inversion.
• Naoki Kobayashi,Ryosuke Sato,Hiroshi Unno,Predicate abstraction and CEGAR for higher-order model checking.
• Keshav Pingali,Donald Nguyen,Milind Kulkarni,Martin Burtscher,Muhammad Amber Hassaan,Rashid Kaleem,Tsung-Hsien Lee,Andrew Lenharth,Roman Manevich,Mario Méndez-Lojo,Dimitrios Prountzos,Xin Sui,The tao of parallelism in algorithms.
• Saturnino Garcia,Donghwan Jeon,Christopher M. Louie,Michael Bedford Taylor,Kremlin: rethinking and rebooting gprof for the multicore age.
• Sumit Gulwani,Susmit Jha,Ashish Tiwari,Ramarathnam Venkatesan,Synthesis of loop-free programs.
• Micah J. Best,Shane Mottishaw,Craig Mustard,Mark Roth,Alexandra Fedorova,Andrew Brownsword,Synchronization via scheduling: techniques for efficiently managing shared state.
• Varun Srivastava,Michael D. Bond,Kathryn S. McKinley,Vitaly Shmatikov,A security policy oracle: detecting security holes using multiple API implementations.
• Sam Tobin-Hochstadt,Vincent St-Amour,Ryan Culpepper,Matthew Flatt,Matthias Felleisen,Languages as libraries.
• Isil Dillig,Thomas Dillig,Alex Aiken,Mooly Sagiv,Precise and compact modular procedure summaries for heap manipulating programs.
• Derek Gordon Murray,Michael Isard,Yuan Yu,Steno: automatic optimization of declarative queries.
• Adrian Sampson,Werner Dietl,Emily Fortuna,Danushen Gnanapragasam,Luis Ceze,Dan Grossman,EnerJ: approximate data types for safe and general low-power computation.
• Deokhwan Kim,Martin C. Rinard,Verification of semantic commutativity conditions and inverse operations on linked data structures.
• Manu Jose,Rupak Majumdar,Cause clue clauses: error localization using maximum satisfiability.
• Qiang Zeng,Dinghao Wu,Peng Liu,Cruiser: concurrent heap buffer overflow monitoring using lock-free data structures.
• Shigeyuki Sato,Hideya Iwasaki,Automatic parallelization via matrix multiplication.
• Hucheng Zhou,Wenguang Chen,Fred C. Chow,An SSA-based algorithm for optimal speculative code motion under an execution profile.
• Brandon Lucia,Benjamin P. Wood,Luis Ceze,Isolating and understanding concurrency errors using reconstructed execution fragments.
• Jaroslav Sevcík,Safe optimisations for shared-memory concurrent programs.
• Ashwin Prasad,Jayvant Anantpur,R. Govindarajan,Automatic compilation of MATLAB programs for synergistic execution on heterogeneous processors.
• Changhee Jung,Silvius Rus,Brian P. Railing,Nathan Clark,Santosh Pande,Brainy: effective selection of data structures.
• Daniele Cono D'Elia,Camil Demetrescu,Irene Finocchi,Mining hot calling contexts in small space.
• Igor Böhm,Tobias J. K. Edler von Koch,Stephen C. Kyle,Björn Franke,Nigel P. Topham,Generalized just-in-time trace compilation using a parallel task farm in a dynamic binary translator.
• Sumit Gulwani,Vijay Anand Korthikanti,Ashish Tiwari,Synthesizing geometry constructions.
• Jean-Baptiste Tristan,Paul Govereau,Greg Morrisett,Evaluating value-graph translation validation for LLVM.
• Kyu Hyung Lee,Yunhui Zheng,Nick Sumner,Xiangyu Zhang,Toward generating reducible replay logs.
• Xuejun Yang,Yang Chen,Eric Eide,John Regehr,Finding and understanding bugs in C compilers.
• Jacob Burnim,Tayfun Elmas,George C. Necula,Koushik Sen,NDSeq: runtime checking for nondeterministic sequential specifications of parallel correctness.
• Percy Liang,Mayur Naik,Scaling abstraction refinement via pruning.
• Juan Antonio Navarro Pérez,Andrey Rybalchenko,Separation logic + superposition calculus = heap theorem prover.
• Arun Raman,Hanjun Kim,Taewook Oh,Jae W. Lee,David I. August,Parallelism orchestration using DoPE: the degree of parallelism executive.
• Terence Parr,Kathleen Fisher,LL(*): the foundation of the ANTLR parser generator.
• Milind Kulkarni,Donald Nguyen,Dimitrios Prountzos,Xin Sui,Keshav Pingali,Exploiting the commutativity lattice.
• Prakash Prabhu,Soumyadeep Ghosh,Yun Zhang,Nick P. Johnson,David I. August,Commutative set: a language extension for implicit parallel programming.
• Jason Ansel,Petr Marchenko,Úlfar Erlingsson,Elijah Taylor,Brad Chen,Derek L. Schuff,David Sehr,Cliff Biffle,Bennet Yee,Language-independent sandboxing of just-in-time compilation and self-modifying code.
• Nels E. Beckman,Aditya V. Nori,Probabilistic, modular and scalable inference of typestate specifications.
• Daniel Marino,Abhayendra Singh,Todd D. Millstein,Madanlal Musuvathi,Satish Narayanasamy,A case for an SC-preserving compiler.
• Aditya Budi,David Lo,Lingxiao Jiang,Lucia,kb-anonymity: a model for anonymized behaviour-preserving test and debugging data.
• Thomas B. Jablin,Prakash Prabhu,James A. Jablin,Nick P. Johnson,Stephen R. Beard,David I. August,Automatic CPU-GPU communication management and optimization.
• Ahmed Bouajjani,Cezara Dragoi,Constantin Enea,Mihaela Sighireanu,On inter-procedural analysis of programs with lists and data.
• John Altidor,Shan Shan Huang,Yannis Smaragdakis,Taming the wildcards: combining definition- and use-site variance.
• Michael Kuperstein,Martin T. Vechev,Eran Yahav,Partial-coherence abstractions for relaxed memory models.
• Dongyun Jin,Patrick O'Neil Meredith,Dennis Griffith,Grigore Rosu,Garbage collection for monitoring parametric properties.
• Adam Chlipala,Mostly-automated verification of low-level programs in computational separation logic.
• Abhishek Udupa,Kaushik Rajan,William Thies,ALTER: exploiting breakable dependences for parallelization.
• William R. Harris,Sumit Gulwani,Spreadsheet table transformations from examples.
• Guoliang Jin,Linhai Song,Wei Zhang,Shan Lu,Ben Liblit,Automated atomicity-violation fixing.
• Patrice Godefroid,Higher-order test generation.
• Peter Hawkins,Alex Aiken,Kathleen Fisher,Martin C. Rinard,Mooly Sagiv,Data representation synthesis.

2010

• Mahmut T. Kandemir,Taylan Yemliha,Sai Prashanth Muralidhara,Shekhar Srikantaiah,Mary Jane Irwin,Yuanrui Zhang,Cache topology aware computation mapping for multicores.
• Yang Chen,Yuanjie Huang,Lieven Eeckhout,Grigori Fursin,Liang Peng,Olivier Temam,Chengyong Wu,Evaluating iterative optimization across 1000 datasets.
• Ross Tate,Juan Chen,Chris Hawblitzel,Inferable object-oriented typed assembly language.
• Sumit Gulwani,Florian Zuleger,The reachability-bound problem.
• Qian Xi,David Walker,A context-free markup language for semi-structured text.
• Sebastian Burckhardt,Chris Dern,Madanlal Musuvathi,Roy Tan,Line-up: a complete and automatic linearizability checker.
• Emina Torlak,Mandana Vaziri,Julian Dolby,MemSAT: checking axiomatic specifications of memory models.
• Viktor Kuncak,Mikaël Mayer,Ruzica Piskac,Philippe Suter,Complete functional synthesis.
• Zachary Tatlock,Sorin Lerner,Bringing extensibility to verified compilers.
• Jennifer B. Sartor,Stephen M. Blackburn,Daniel Frampton,Martin Hirzel,Kathryn S. McKinley,Z-rays: divide arrays and conquer speed and flexibility.
• Jean Yang,Chris Hawblitzel,Safe to the last instruction: automated verification of a type-safe operating system.
• Gregor Richards,Sylvain Lebresne,Brian Burg,Jan Vitek,An analysis of the dynamic behavior of JavaScript programs.
• Cormac Flanagan,Stephen N. Freund,Adversarial memory for detecting destructive races.
• Swarat Chaudhuri,Armando Solar-Lezama,Smooth interpretation.
• Byeongcheol Lee,Ben Wiedermann,Martin Hirzel,Robert Grimm,Kathryn S. McKinley,Jinn: synthesizing dynamic bug detectors for foreign language interfaces.
• Florian Loitsch,Printing floating-point numbers quickly and accurately with integers.
• Takuya Nakaike,Maged M. Michael,Lock elision for read-only critical sections in Java.
• Michael Emmi,Rupak Majumdar,Roman Manevich,Parameterized verification of transactional memories.
• Yi Yang,Ping Xiang,Jingfei Kong,Huiyang Zhou,A GPGPU compiler for memory optimization and parallelism management.
• Md Kamruzzaman,Steven Swanson,Dean M. Tullsen,Software data spreading: leveraging distributed caches to improve single thread performance.
• Adam Chlipala,Ur: statically-typed metaprogramming with type-level record computation.
• Yit Phang Khoo,Bor-Yuh Evan Chang,Jeffrey S. Foster,Mixing type checking and symbolic execution.
• Jin Zhou,Brian Demsky,Bamboo: a data-centric, object-oriented approach to many-core software.
• Olatunji Ruwase,Shimin Chen,Phillip B. Gibbons,Todd C. Mowry,Decoupled lifeguards: enabling path optimizations for dynamic correctness checking tools.
• Edwin M. Westbrook,Mathias Ricken,Jun Inoue,Yilong Yao,Tamer Abdelatif,Walid Taha,Mint: Java multi-stage programming using weak separability.
• Heidi Pan,Benjamin Hindman,Krste Asanovic,Composing parallel software efficiently with lithe.
• Guoqing (Harry) Xu,Nick Mitchell,Matthew Arnold,Atanas Rountev,Edith Schonberg,Gary Sevitsky,Finding low-utility data structures.
• Woongki Baek,Trishul M. Chilimbi,Green: a framework for supporting energy-conscious programming using controlled approximation.
• Umut A. Acar,Guy E. Blelloch,Ruy Ley-Wild,Kanat Tangwongsan,Duru Türkoglu,Traceable data types for self-adjusting computation.
• Prakash Prabhu,Ganesan Ramalingam,Kapil Vaswani,Safe programmable speculative parallelism.
• Michael D. Bond,Katherine E. Coons,Kathryn S. McKinley,PACER: proportional detection of data races.
• Daniel Marino,Abhayendra Singh,Todd D. Millstein,Madanlal Musuvathi,Satish Narayanasamy,DRFX: a simple and efficient memory model for concurrent programming languages.
• Kaushik Rajan,Sriram K. Rajamani,Shashank Yaduvanshi,GUESSTIMATE: a programming model for collaborative distributed systems.
• Michael D. Bond,Graham Z. Baker,Samuel Z. Guyer,Breadcrumbs: efficient context sensitivity for dynamic bug detection analyses.
• Todd Mytkowicz,Amer Diwan,Matthias Hauswirth,Peter F. Sweeney,Evaluating the accuracy of Java profilers.
• Guoqing (Harry) Xu,Atanas Rountev,Detecting inefficiently-used containers to avoid bloat.
• Juan Chen,Ravi Chugh,Nikhil Swamy,Type-preserving compilation of end-to-end verification of security enforcement.
• Filip Pizlo,Lukasz Ziarek,Petr Maj,Antony L. Hosking,Ethan Blanton,Jan Vitek,Schism: fragmentation-tolerant real-time garbage collection.
• Craig Chambers,Ashish Raniwala,Frances Perry,Stephen Adams,Robert R. Henry,Robert Bradshaw,Nathan Weizenbaum,FlumeJava: easy, efficient data-parallel pipelines.
• Matthew Might,Yannis Smaragdakis,David Van Horn,Resolving and exploiting the k-CFA paradox: illuminating functional vs. object-oriented program analysis.
• Chen Tian,Min Feng,Rajiv Gupta,Supporting speculative parallelization in the presence of dynamic data structures.

2009

• Indrajit Roy,Donald E. Porter,Michael D. Bond,Kathryn S. McKinley,Emmett Witchel,Laminar: practical fine-grained decentralized information flow control.
• Zachary R. Anderson,David Gay,Mayur Naik,Lightweight annotations for controlling sharing in concurrent data structures.
• Salvatore La Torre,Parthasarathy Madhusudan,Gennaro Parlato,Analyzing recursive programs using a fixed-point calculus.
• Jason Ansel,Cy P. Chan,Yee Lok Wong,Marek Olszewski,Qin Zhao,Alan Edelman,Saman P. Amarasinghe,PetaBricks: a language and compiler for algorithmic choice.
• Ravi Chugh,Jeffrey A. Meister,Ranjit Jhala,Sorin Lerner,Staged information flow for javascript.
• Omer Tripp,Marco Pistoia,Stephen J. Fink,Manu Sridharan,Omri Weisman,TAJ: effective taint analysis of web applications.
• Suriya Subramanian,Michael W. Hicks,Kathryn S. McKinley,Dynamic software updates: a VM-centric approach.
• Yutaka Oiwa,Implementation of the memory-safe full ANSI-C compiler.
• Tristan Ravitch,Steve Jackson,Eric Aderhold,Ben Liblit,Automatic generation of library bindings using static analysis.
• Sumit Gulwani,Sagar Jain,Eric Koskinen,Control-flow refinement and progress invariants for bound analysis.
• Daniel Marino,Madanlal Musuvathi,Satish Narayanasamy,LiteRace: effective sampling for lightweight data-race detection.
• Matthew A. Hammer,Umut A. Acar,Yan Chen,CEAL: a C-based language for self-adjusting computation.
• Iulian Neamtiu,Michael W. Hicks,Safe and timely updates to multi-threaded programs.
• Tillmann Rendel,Klaus Ostermann,Christian Hofer,Typed self-representation.
• Andreas Gal,Brendan Eich,Mike Shaver,David Anderson,David Mandelin,Mohammad R. Haghighat,Blake Kaplan,Graydon Hoare,Boris Zbarsky,Jason Orendorff,Jesse Ruderman,Edwin W. Smith,Rick Reitmaier,Michael Bebenita,Mason Chang,Michael Franz,Trace-based just-in-time type specialization for dynamic languages.
• Saurabh Srivastava,Sumit Gulwani,Program verification using templates over predicate abstraction.
• Sudipta Kundu,Zachary Tatlock,Sorin Lerner,Proving optimizations correct using parameterized program equivalence.
• Pieter Hooimeijer,Westley Weimer,A decision procedure for subset constraints over regular languages.
• Kevin J. Hoffman,Patrick Eugster,Suresh Jagannathan,Semantics-aware trace analysis.
• Ohad Shacham,Martin T. Vechev,Eran Yahav,Chameleon: adaptive selection of collections.
• Mojtaba Mehrara,Jeff Hao,Po-Chun Hsu,Scott A. Mahlke,Parallelizing sequential applications on commodity hardware using a low-cost software transactional memory.
• Pallavi Joshi,Chang-Seo Park,Koushik Sen,Mayur Naik,A randomized dynamic program analysis technique for detecting real deadlocks.
• V. Benjamin Livshits,Aditya V. Nori,Sriram K. Rajamani,Anindya Banerjee,Merlin: specification inference for explicit information flow problems.
• Edward Aftandilian,Samuel Z. Guyer,GC assertions: using the garbage collector to check heap properties.
• August Schwerdfeger,Eric Van Wyk,Verifiable composition of deterministic grammars.
• Nathan R. Tallent,John M. Mellor-Crummey,Michael W. Fagan,Binary analysis for measurement and attribution of program performance.
• Karen Zee,Viktor Kuncak,Martin C. Rinard,An integrated proof language for imperative programs.
• Cormac Flanagan,Stephen N. Freund,FastTrack: efficient and precise dynamic race detection.
• Jean-Baptiste Tristan,Xavier Leroy,Verified validation of lazy code motion.
• Aleksandar Dragojevic,Rachid Guerraoui,Michal Kapalka,Stretching transactional memory.
• Satish Chandra,Stephen J. Fink,Manu Sridharan,Snugglebug: a powerful approach to weakest preconditions.
• Cindy Rubio-González,Haryadi S. Gunawi,Ben Liblit,Remzi H. Arpaci-Dusseau,Andrea C. Arpaci-Dusseau,Error propagation analysis for file systems.
• Hiroshi Inoue,Hideaki Komatsu,Toshio Nakatani,A study of memory management for web-based applications on multicore processors.
• Ming Kawaguchi,Patrick Maxim Rondon,Ranjit Jhala,Type-based data structure verification.
• Guoqing (Harry) Xu,Matthew Arnold,Nick Mitchell,Atanas Rountev,Gary Sevitsky,Go with the flow: profiling copies to find runtime bloat.
• Erez Petrank,Madanlal Musuvathi,Bjarne Steensgaard,Progress guarantee for parallel programs via bounded lock-freedom.
• Bratin Saha,Xiaocheng Zhou,Hu Chen,Ying Gao,Shoumeng Yan,Mohan Rajagopalan,Jesse Fang,Peinan Zhang,Ronny Ronen,Avi Mendelson,Programming model for a heterogeneous x86 platform.
• Xin Qi,Andrew C. Myers,Sharing classes between families.
• Georgios Tournavitis,Zheng Wang,Björn Franke,Michael F. P. O'Boyle,Towards a holistic approach to auto-parallelization: integrating profile-driven parallelism detection and machine-learning based mapping.
• Gene Novark,Emery D. Berger,Benjamin G. Zorn,Efficiently and precisely locating memory leaks and bloat.
• Santosh Nagarakatte,Jianzhou Zhao,Milo M. K. Martin,Steve Zdancewic,SoftBound: highly compatible and complete spatial memory safety for c.

2008

• Martin T. Vechev,Eran Yahav,Deriving linearizable fine-grained concurrent objects.
• Stephen McCamant,Michael D. Ernst,Quantitative information flow as network flow capacity.
• Daniel von Dincklage,Amer Diwan,Explaining failures of program analyses.
• Filip Pizlo,Erez Petrank,Bjarne Steensgaard,A study of concurrent real-time garbage collectors.
• Armando Solar-Lezama,Christopher Grant Jones,Rastislav Bodík,Sketching concurrent data structures.
• Isil Dillig,Thomas Dillig,Alex Aiken,Sound, complete and scalable path-sensitive analysis.
• Hans-Juergen Boehm,Sarita V. Adve,Foundations of the C++ concurrency memory model.
• Sumit Gulwani,Saurabh Srivastava,Ramarathnam Venkatesan,Program analysis as constraint solving.
• Nicolas Halbwachs,Mathias Péron,Discovering properties about arrays in simple programs.
• Manjunath Kudlur,Scott A. Mahlke,Orchestrating the execution of stream programs on multicore platforms.
• Shan Shan Huang,Yannis Smaragdakis,Expressive and safe static reflection with MorphJ.
• Tachio Terauchi,Checking race freedom via linear programming.
• Madanlal Musuvathi,Shaz Qadeer,Fair stateless model checking.
• Xi Wang,Zhilei Xu,Xuezheng Liu,Zhenyu Guo,Xiaoge Wang,Zheng Zhang,Conditional correlation analysis for safe region-based memory management.
• Koushik Sen,Race directed random testing of concurrent programs.
• Xinyu Feng,Zhong Shao,Yuan Dong,Yu Guo,Certifying low-level programs with hardware interrupts and preemptive threads.
• Sebastian Hack,Gerhard Goos,Copy coalescing by graph recoloring.
• Fernando Magno Quintão Pereira,Jens Palsberg,Register allocation by puzzle solving.
• Karen Zee,Viktor Kuncak,Martin C. Rinard,Full functional verification of linked data structures.
• Cormac Flanagan,Stephen N. Freund,Jaeheon Yi,Velodrome: a sound and complete dynamic atomicity checker for multithreaded programs.
• Patrice Godefroid,Adam Kiezun,Michael Y. Levin,Grammar-based whitebox fuzzing.
• Michal Wegiel,Chandra Krintz,XMem: type-safe, transparent, shared memory for cross-runtime communication and coordination.
• Vineet Kahlon,Bootstrapping: a technique for scalable flow and context-sensitive pointer alias analysis.
• Bin Xin,William N. Sumner,Xiangyu Zhang,Efficient program execution indexing.
• Rachid Guerraoui,Thomas A. Henzinger,Barbara Jobstmann,Vasu Singh,Model checking transactional memories.
• Ravi Chugh,Jan Wen Voung,Ranjit Jhala,Sorin Lerner,Dataflow analysis for concurrent programs using datarace detection.
• Louis-Noël Pouchet,Cédric Bastoul,Albert Cohen,John Cavazos,Iterative optimization in the polyhedral model: part ii, multidimensional time.
• Uday Bondhugula,Albert Hartono,J. Ramanujam,P. Sadayappan,A practical automatic polyhedral parallelizer and locality optimizer.
• Ahmed M. Amin,Mithuna Thottethodi,T. N. Vijaykumar,Steven Wereley,Stephen C. Jacobson,Automatic volume management for programmable microfluidics.
• Juan Chen,Chris Hawblitzel,Frances Perry,Michael Emmi,Jeremy Condit,Derrick Coetzee,Polyvios Pratikaki,Type-preserving compilation for large-scale optimizing object-oriented compilers.
• Patrick Maxim Rondon,Ming Kawaguchi,Ranjit Jhala,Liquid types.
• Sigmund Cherem,Trishul M. Chilimbi,Sumit Gulwani,Inferring locks for atomic sections.
• Zachary R. Anderson,David Gay,Robert Ennals,Eric A. Brewer,SharC: checking data sharing strategies for multithreaded C.
• Stephen M. Blackburn,Kathryn S. McKinley,Immix: a mark-region garbage collector with space efficiency, fast collection, and mutator performance.

2007

• Tatiana Shpeisman,Vijay Menon,Ali-Reza Adl-Tabatabai,Steven Balensiefer,Dan Grossman,Richard L. Hudson,Katherine F. Moore,Bratin Saha,Enforcing isolation and ordering in STM.
• Feihui Li,Guangyu Chen,Mahmut T. Kandemir,Ibrahim Kolcu,Profile-driven energy reduction in network-on-chips.
• Florian T. Schneider,Mathias Payer,Thomas R. Gross,Online optimizations driven by hardware performance monitoring.
• Milind Kulkarni,Keshav Pingali,Bruce Walter,Ganesh Ramanarayanan,Kavita Bala,L. Paul Chew,Optimistic parallelism requires abstractions.
• Ajeet Shankar,Rastislav Bodík,DITTO: automatic incrementalization of data structure invariant checks (in Java).
• Sigmund Cherem,Lonnie Princehouse,Radu Rugina,Practical memory leak detection using guarded value-flow analysis.
• Gene Novark,Emery D. Berger,Benjamin G. Zorn,Exterminator: automatically correcting memory errors with high probability.
• Pierre Genevès,Nabil Layaïda,Alan Schmitt,Efficient static analysis of XML paths and types.
• Hongxu Cai,Zhong Shao,Alexander Vaynberg,Certified self-modifying code.
• Jungwoo Ha,Christopher J. Rossbach,Jason V. Davis,Indrajit Roy,Hany E. Ramadan,Donald E. Porter,David L. Chen,Emmett Witchel,Improved error reporting for software that uses black-box components.
• John Kodumal,Alex Aiken,Regularly annotated set constraints.
• Bolei Guo,Neil Vachharajani,David I. August,Shape analysis with inductive recursion synthesis.
• Sebastian Burckhardt,Rajeev Alur,Milo M. K. Martin,CheckFence: checking consistency of concurrent data types on relaxed memory models.
• Sriram Krishnamoorthy,Muthu Manikandan Baskaran,Uday Bondhugula,J. Ramanujam,Atanas Rountev,P. Sadayappan,Effective automatic parallelization of stencil computations.
• Perry H. Wang,Jamison D. Collins,Gautham N. Chinya,Hong Jiang,Xinmin Tian,Milind Girkar,Nick Y. Yang,Guei-Yuan Lueh,Hong Wang,EXOCHI: architecture and programming environment for a heterogeneous multi-core multithreaded system.
• Satish Narayanasamy,Zhenghao Wang,Jordan Tigani,Andrew Edwards,Brad Calder,Automatically classifying benign and harmful data racesallusing replay analysis.
• Benjamin S. Lerner,Matthew Flower,Dan Grossman,Craig Chambers,Searching for type-error messages.
• Chen Ding,Xipeng Shen,Kirk Kelsey,Chris Tice,Ruke Huang,Chengliang Zhang,Software behavior oriented parallelization.
• Kazutaka Morita,Akimasa Morihata,Kiminori Matsuzaki,Zhenjiang Hu,Masato Takeichi,Automatic inversion generates divide-and-conquer parallel programs.
• Manu Sridharan,Stephen J. Fink,Rastislav Bodík,Thin slicing.
• Gary Wassermann,Zhendong Su,Sound and precise analysis of web applications for injection vulnerabilities.
• Ben Hardekopf,Calvin Lin,The ant and the grasshopper: fast and accurate pointer analysis for millions of lines of code.
• Byron Cook,Andreas Podelski,Andrey Rybalchenko,Proving thread termination.
• Madanlal Musuvathi,Shaz Qadeer,Iterative context bounding for systematic testing of multithreaded programs.
• Weijia Li,Youtao Zhang,Jun Yang,Jiang Zheng,UCC: update-conscious compilation for energy efficiency in wireless sensor networks.
• Armando Solar-Lezama,Gilad Arnold,Liviu Tancau,Rastislav Bodík,Vijay A. Saraswat,Sanjit A. Seshia,Sketching stencils.
• Isil Dillig,Thomas Dillig,Alex Aiken,Static error detection using semantic inconsistency inference.
• Alexey Gotsman,Josh Berdine,Byron Cook,Mooly Sagiv,Thread-modular shape analysis.
• Nicholas Nethercote,Julian Seward,Valgrind: a framework for heavyweight dynamic binary instrumentation.
• Xiangyu Zhang,Sriraman Tallam,Neelam Gupta,Rajiv Gupta,Towards locating execution omission errors.
• Murali Krishna Ramanathan,Ananth Grama,Suresh Jagannathan,Static specification inference using predicate mining.
• Erika Rice Scherpelz,Sorin Lerner,Craig Chambers,Automatic inference of optimizer flow functions from semantic meanings.
• Nupur Kothari,Ramakrishna Gummadi,Todd D. Millstein,Ramesh Govindan,Reliable and efficient programming abstractions for wireless sensor networks.
• Peng Li,Steve Zdancewic,Combining events and threads for scalable network services implementation and evaluation of monadic, application-level concurrency primitives.
• Tayfun Elmas,Shaz Qadeer,Serdar Tasiran,Goldilocks: a race and transaction-aware java runtime.
• Ben Titzer,Joshua S. Auerbach,David F. Bacon,Jens Palsberg,The ExoVM system for automatic VM and application reduction.
• Frances Perry,Lester W. Mackey,George A. Reis,Jay Ligatti,David I. August,David Walker,Fault-tolerant typed assembly language.
• Adam Chlipala,A certified type-preserving compiler from lambda calculus to assembly language.
• Lakshminarayanan Renganarayanan,DaeGon Kim,Sanjay V. Rajopadhye,Michelle Mills Strout,Parameterized tiled loops for free.
• Nathan Cooprider,John Regehr,Offline compression for on-chip ram.
• Martin T. Vechev,Eran Yahav,David F. Bacon,Noam Rinetzky,CGCExplorer: a semi-automated search procedure for provably correct concurrent collectors.
• Dirk Beyer,Thomas A. Henzinger,Rupak Majumdar,Andrey Rybalchenko,Path invariants.
• Charles Edwin Killian,James W. Anderson,Ryan Braud,Ranjit Jhala,Amin Vahdat,Mace: language support for building distributed systems.
• Andrew McCreight,Zhong Shao,Chunxiao Lin,Long Li,A general framework for certifying garbage collectors and their mutators.
• Chris Lattner,Andrew Lenharth,Vikram S. Adve,Making context-sensitive points-to analysis with heap cloning practical for the real world.

2006

• Iulian Neamtiu,Michael W. Hicks,Gareth Stoyle,Manuel Oriol,Practical dynamic software updating for C.
• Manu Sridharan,Rastislav Bodík,Refinement-based context-sensitive points-to analysis for Java.
• Jeremy Lau,Matthew Arnold,Michael Hind,Brad Calder,Online performance auditing: using hot optimizations without getting burned.
• Martin T. Vechev,Eran Yahav,David F. Bacon,Correctness-preserving derivation of concurrent garbage collection algorithms.
• Takuya Nakaike,Tatsushi Inagaki,Hideaki Komatsu,Toshio Nakatani,Profile-based global live-range splitting.
• Xiangyu Zhang,Neelam Gupta,Rajiv Gupta,Pruning dynamic slices with confidence.
• Matthew J. Bridges,Neil Vachharajani,Guilherme Ottoni,David I. August,Automatic instruction scheduler retargeting by reverse-engineering.
• Brian D. Carlstrom,Austen McDonald,Hassan Chafi,JaeWoong Chung,Chi Cao Minh,Christoforos E. Kozyrakis,Kunle Olukotun,The Atomos transactional programming language.
• Dinakar Dhurjati,Sumant Kowshik,Vikram S. Adve,SAFECode: enforcing alias analysis for weakly typed languages.
• Trishul M. Chilimbi,Ran Shaham,Cache-conscious coallocation of hot data streams.
• Xiaotong Zhuang,Mauricio J. Serrano,Harold W. Cain,Jong-Deok Choi,Accurate, efficient, and adaptive calling context profiling.
• Byron Cook,Andreas Podelski,Andrey Rybalchenko,Termination proofs for systems code.
• Olin Shivers,Matthew Might,Continuations and transducer composition.
• Robert Grimm,Better extensibility through modular syntax.
• Ali-Reza Adl-Tabatabai,Brian T. Lewis,Vijay Menon,Brian R. Murphy,Bratin Saha,Tatiana Shpeisman,Compiler and runtime support for efficient software transactional memory.
• Haim Kermany,Erez Petrank,The Compressor: concurrent, incremental, and parallel compaction.
• Dorit Nuzman,Ira Rosen,Ayal Zaks,Auto-vectorization of interleaved data for SIMD.
• David Ryan Koes,Seth Copen Goldstein,A global progressive register allocator.
• Gang Ren,Peng Wu,David A. Padua,Optimizing data permutations for SIMD devices.
• Troy A. Johnson,Rudolf Eigenmann,Context-sensitive domain-independent algorithm composition and selection.
• Christopher Barton,Calin Cascaval,George Almási,Yili Zheng,Montse Farreras,Siddhartha Chatterjee,José Nelson Amaral,Shared memory programming for large scale machines.
• M. Anton Ertl,Kevin Casey,David Gregg,Fast and flexible instruction selection with on-demand tree-parsing automata.
• Wen-ke Chen,Sanjay Bhansali,Trishul M. Chilimbi,Xiaofeng Gao,Weihaw Chuang,Profile-guided proactive garbage collection for locality optimization.
• Samuel Z. Guyer,Kathryn S. McKinley,Daniel Frampton,Free-Me: a static analysis for automatic individual object reclamation.
• Guangyu Chen,Feihui Li,Mahmut T. Kandemir,Mary Jane Irwin,Reducing NoC energy consumption through compiler-directed channel voltage scaling.
• Timothy L. Harris,Mark Plesko,Avraham Shinnar,David Tarditi,Optimizing memory transactions.
• Mayur Naik,Alex Aiken,John Whaley,Effective static race detection for Java.
• Umut A. Acar,Guy E. Blelloch,Matthias Blume,Kanat Tangwongsan,An experimental analysis of self-adjusting computation.
• Daniel Spoonhower,Joshua S. Auerbach,David F. Bacon,Perry Cheng,David Grove,Eventrons: a safe programming construct for high-frequency hard real-time applications.
• Emery D. Berger,Benjamin G. Zorn,DieHard: probabilistic memory safety for unsafe languages.
• Long Fei,Samuel P. Midkiff,Artemis: practical runtime monitoring of applications for execution anomalies.
• Spyridon Triantafyllis,Matthew J. Bridges,Easwaran Raman,Guilherme Ottoni,David I. August,A framework for unrestricted whole-program optimization.
• Polyvios Pratikakis,Jeffrey S. Foster,Michael W. Hicks,LOCKSMITH: context-sensitive correlation analysis for race detection.
• Xinyu Feng,Zhong Shao,Alexander Vaynberg,Sen Xiang,Zhaozhong Ni,Modular verification of assembly code with stack-based control abstractions.
• Jaakko Järvi,Douglas Gregor,Jeremiah Willcock,Andrew Lumsdaine,Jeremy G. Siek,Algorithm specialization in generic programming: challenges of constrained generics in C++.
• Sumit Gulwani,Ashish Tiwari,Combining abstract interpreters.

2005

• Hongbo Rong,Alban Douillet,Guang R. Gao,Register allocation for software pipelined multi-dimensional loops.
• Carlos García Quiñones,Carlos Madriles,F. Jesús Sánchez,Pedro Marcuello,Antonio González,Dean M. Tullsen,Mitosis compiler: an infrastructure for speculative threading based on pre-computation slices.
• David Mandelin,Lin Xu,Rastislav Bodík,Doug Kimelman,Jungloid mining: helping to navigate the API jungle.
• Alex Aletà,Josep M. Codina,Antonio González,David R. Kaeli,Demystifying on-the-fly spill code.
• Brian Chin,Shane Markstrum,Todd D. Millstein,Semantic type qualifiers.
• Min Xu,Rastislav Bodík,Mark D. Hill,A serializability violation detector for shared-memory server programs.
• Ranjit Jhala,Rupak Majumdar,Path slicing.
• Ben Liblit,Mayur Naik,Alice X. Zheng,Alexander Aiken,Michael I. Jordan,Scalable statistical bug isolation.
• Daniel A. Jiménez,Code placement for improving dynamic branch prediction accuracy.
• Xiaotong Zhuang,Santosh Pande,Differential register allocation.
• Michael K. Chen,Xiao-Feng Li,Ruiqi Lian,Jason H. Lin,Lixia Liu,Tao Liu,Roy Ju,Shangri-La: achieving high performance from compiled network applications while enabling ease of programming.
• Tayfun Elmas,Serdar Tasiran,Shaz Qadeer,VYRD: verifYing concurrent programs by runtime refinement-violation detection.
• Jeremy G. Siek,Andrew Lumsdaine,Essential language support for generic programming.
• Neelakantan R. Krishnaswami,Jonathan Aldrich,Permission-based ownership: encapsulating state in higher-order typed languages.
• Matthew Hertz,Yi Feng,Emery D. Berger,Garbage collection without paging.
• Andrew Ayers,Richard Schooler,Chris Metcalf,Anant Agarwal,Junghwan Rhee,Emmett Witchel,TraceBack: first fault diagnosis by reconstruction of distributed control flow.
• Lujo Bauer,Jay Ligatti,David Walker,Composing security policies with polymer.
• Patrice Godefroid,Nils Klarlund,Koushik Sen,DART: directed automated random testing.
• Kathleen Fisher,Robert Gruber,PADS: a domain-specific language for processing ad hoc data.
• Pavel Avgustinov,Aske Simon Christensen,Laurie J. Hendren,Sascha Kuzins,Jennifer Lhoták,Ondrej Lhoták,Oege de Moor,Damien Sereni,Ganesh Sittampalam,Julian Tibble,Optimising aspectJ.
• Yang Ni,Ulrich Kremer,Adrian Stere,Liviu Iftode,Programming ad-hoc networks of mobile and resource-constrained devices.
• Chris Lattner,Vikram S. Adve,Automatic pool allocation: improving performance by controlling data structure layout in the heap.
• Michael Furr,Jeffrey S. Foster,Checking type safety of foreign function calls.
• Chi-Keung Luk,Robert S. Cohn,Robert Muth,Harish Patil,Artur Klauser,P. Geoffrey Lowney,Steven Wallace,Vijay Janapa Reddi,Kim M. Hazelwood,Pin: building customized program analysis tools with dynamic instrumentation.
• Franz Franchetti,Yevgen Voronenko,Markus Püschel,Formal loop merging for signal transforms.
• Jinquan Dai,Bo Huang,Long Li,Luddy Harrison,Automatically partitioning packet processing applications for pipelined architectures.
• Hans-Juergen Boehm,Threads cannot be implemented as a library.
• Armando Solar-Lezama,Rodric M. Rabbah,Rastislav Bodík,Kemal Ebcioglu,Programming by sketching for bit-streaming programs.

2004

• Troy A. Johnson,Rudolf Eigenmann,T. N. Vijaykumar,Min-cut program decomposition for thread-level speculation.
• John Whaley,Monica S. Lam,Cloning-based context-sensitive pointer alias analysis using binary decision diagrams.
• Alexandre E. Eichenberger,Peng Wu,Kevin O'Brien,Vectorization for SIMD architectures with alignment constraints.
• Xiaotong Zhuang,Santosh Pande,Balancing register allocation across threads for a multithreaded network processor.
• Ali-Reza Adl-Tabatabai,Richard L. Hudson,Mauricio J. Serrano,Sreenivas Subramoney,Prefetch inection based on hardware monitoring and object metadata.
• Yutao Zhong,Maksim Orlovich,Xipeng Shen,Chen Ding,Array regrouping and structure splitting using whole-program reference affinity.
• Matthew Flatt,Robert Bruce Findler,Kill-safe synchronization abstractions.
• Michael D. Smith,Norman Ramsey,Glenn H. Holloway,A generalized algorithm for graph-coloring register allocation.
• Zhao-Hui Du,Chu-Cheow Lim,Xiao-Feng Li,Chen Yang,Qingyu Zhao,Tin-Fook Ngai,A cost-driven compilation framework for speculative parallelization of sequential programs.
• Manish Vachharajani,Neil Vachharajani,David I. August,The liberty structural specification language: a high-level modeling language for component reuse.
• Eran Yahav,G. Ramalingam,Verifying safety properties using separation and heterogeneous abstractions.
• John Kodumal,Alexander Aiken,The set constraint/CFL reachability connection in practice.
• Arnaud Venet,Guillaume P. Brat,Precise and efficient static array bound checking for large embedded C programs.
• Xiangyu Zhang,Rajiv Gupta,Cost effective dynamic program slicing.
• Ondrej Lhoták,Laurie J. Hendren,Jedd: a BDD-based relational extension of Java.
• Jianwen Zhu,Silvian Calman,Symbolic pointer analysis revisited.
• Christian S. Collberg,Edward Carter,Saumya K. Debray,Andrew Huntwork,John D. Kececioglu,Cullen Linn,Michael Stepp,Dynamic path-based software watermarking.
• Cheng Wang,Zhiyuan Li,Parametric analysis for adaptive computation offloading.
• Prasad A. Kulkarni,Stephen Hines,Jason Hiser,David B. Whalley,Jack W. Davidson,Douglas L. Jones,Fast searches for effective optimization phase sequences.
• Maged M. Michael,Scalable lock-free dynamic memory allocation.
• Thomas A. Henzinger,Ranjit Jhala,Rupak Majumdar,Race checking by context inference.
• Yanhong A. Liu,Tom Rothamel,Fuxiang Yu,Scott D. Stoller,Nanjun Hu,Parametric regular path queries.
• John Cavazos,J. Eliot B. Moss,Inducing heuristics to decide whether to schedule.
• Shaz Qadeer,Dinghao Wu,KISS: keep it simple and sequential.
• Wei-Ngan Chin,Florin Craciun,Shengchao Qin,Martin C. Rinard,Region inference for an object-oriented language.

2003

• Nurit Dor,Michael Rodeh,Shmuel Sagiv,CSSV: towards a realistic tool for statically detecting all buffer overflows in C.
• Bruno Blanchet,Patrick Cousot,Radhia Cousot,Jérôme Feret,Laurent Mauborgne,Antoine Miné,David Monniaux,Xavier Rival,A static analyzer for large safety-critical software.
• Tatsushi Inagaki,Tamiya Onodera,Hideaki Komatsu,Toshio Nakatani,Stride prefetching by dynamically inspecting objects.
• Ben Liblit,Alexander Aiken,Alice X. Zheng,Michael I. Jordan,Bug isolation via remote program sampling.
• Glenn Ammons,David Mandelin,Rastislav Bodík,James R. Larus,Debugging temporal specifications with concept analysis.
• Andrew A. Lamb,William Thies,Saman P. Amarasinghe,Linear analysis and optimization of stream programs.
• Kamen Yotov,Xiaoming Li,Gang Ren,Michael Cibulskis,Gerald DeJong,María Jesús Garzarán,David A. Padua,Keshav Pingali,Paul Stodghill,Peng Wu,A comparison of empirical and model-driven optimization.
• Toshio Suganuma,Toshiaki Yasue,Toshio Nakatani,A region-based compilation technique for a Java just-in-time compiler.
• Mark Stephenson,Saman P. Amarasinghe,Martin C. Martin,Una-May O'Reilly,Meta optimization: improving compiler heuristics with machine learning.
• David Gay,Philip Levis,J. Robert von Behren,Matt Welsh,Eric A. Brewer,David E. Culler,The nesC language: A holistic approach to networked embedded systems.
• Juan Chen,Dinghao Wu,Andrew W. Appel,Hai Fang,A provably sound TAL for back-end optimization.
• Chen Ding,Yutao Zhong,Predicting whole-program locality through reuse distance analysis.
• Lal George,Matthias Blume,Taming the IXP network processor.
• Sorin Lerner,Todd D. Millstein,Craig Chambers,Automatically proving the correctness of compiler optimizations.
• Michael L. Chu,Kevin Fan,Scott A. Mahlke,Region-based hierarchical operation partitioning for multicluster processors.
• Chandrasekhar Boyapati,Alexandru Salcianu,William S. Beebee,Martin C. Rinard,Ownership types for safe region-based memory management in real-time Java.
• Michelle Mills Strout,Larry Carter,Jeanne Ferrante,Compile-time composition of run-time data and iteration reorderings.
• Fen Xie,Margaret Martonosi,Sharad Malik,Compile-time dynamic voltage scaling settings: opportunities and limits.
• Cormac Flanagan,Shaz Qadeer,A type and effect system for atomicity.
• Alexander Aiken,Jeffrey S. Foster,John Kodumal,Tachio Terauchi,Checking and inferring local non-aliasing.
• M. Anton Ertl,David Gregg,Optimizing indirect branch prediction accuracy in virtual machine interpreters.
• Jeremy Condit,Matthew Harren,Scott McPeak,George C. Necula,Westley Weimer,CCured in the real world.
• Jin Lin,Tong Chen,Wei-Chung Hsu,Pen-Chung Yew,Roy Dz-Ching Ju,Tin-Fook Ngai,Sun Chan,A compiler framework for speculative analysis and optimizations.
• Marc Berndl,Ondrej Lhoták,Feng Qian,Laurie J. Hendren,Navindra Umanee,Points-to analysis using BDDs.
• Christoph von Praun,Thomas R. Gross,Static conflict analysis for multi-threaded object-oriented programs.
• David L. Heine,Monica S. Lam,A practical flow-sensitive and context-sensitive C and C++ memory leak detector.
• Chung-Hsing Hsu,Ulrich Kremer,The design, implementation, and evaluation of a compiler algorithm for CPU energy reduction.
• Pramod G. Joisha,Prithviraj Banerjee,Static array storage optimization in MATLAB.

2002

• Shih-Wei Liao,Perry H. Wang,Hong Wang,John Paul Shen,Gerolf Hoflehner,Daniel M. Lavery,Post-Pass Binary Adaptation for Software-Based Speculative Precomputation.
• Cormac Flanagan,K. Rustan M. Leino,Mark Lillibridge,Greg Nelson,James B. Saxe,Raymie Stata,Extended Static Checking for Java.
• Karthik Gargi,A Sparse Algorithm for Predicated Global Value Numbering.
• Rajeev Joshi,Greg Nelson,Keith H. Randall,Denali: A Goal-directed Superoptimizer.
• Youfeng Wu,Efficient Discovery of Regular Stride Patterns in Irregular Programs.
• Stephen Blackburn,Richard E. Jones,Kathryn S. McKinley,J. Eliot B. Moss,Beltway: Getting Around Garbage Collection Gridlock.
• Jason Baker,Wilson C. Hsieh,Maya: Multiple-Dispatch Syntax Extension in Java.
• Dan Grossman,J. Gregory Morrisett,Trevor Jim,Michael W. Hicks,Yanling Wang,James Cheney,Region-Based Memory Management in Cyclone.
• Trishul M. Chilimbi,Martin Hirzel,Dynamic Hot Data Stream Prefetching for General-Purpose Programs.
• Daniel Cociorva,Gerald Baumgartner,Chi-Chung Lam,P. Sadayappan,J. Ramanujam,Marcel Nooijen,David E. Bernholdt,Robert J. Harrison,Space-Time Trade-Off Optimization for a Class of Electronic Structure Calculations.
• Yoav Ossia,Ori Ben-Yitzhak,Irit Goft,Elliot K. Kolodner,Victor Leikehman,Avi Owshanko,A Parallel, Incremental and Concurrent GC for Servers.
• Motohiro Kawahito,Hideaki Komatsu,Toshio Nakatani,Effective Sign Extension Elimination.
• Niels Hallenberg,Martin Elsman,Mads Tofte,Combining Region Inference and Garbage Collection.
• Mohan Rajagopalan,Saumya K. Debray,Matti A. Hiltunen,Richard D. Schlichting,Profile-Directed Optimization of Event-Based Programs.
• Saumya K. Debray,William S. Evans,Profile-Guided Code Compression.
• Martin Burtscher,Amer Diwan,Matthias Hauswirth,Static Load Classification for Improving the Value Predictability of Data-Cache Misses.
• Akira Koseki,Hideaki Komatsu,Toshio Nakatani,Preference-Directed Graph Coloring.
• Manuvir Das,Sorin Lerner,Mark Seigle,ESP: Path-Sensitive Program Verification in Polynomial Time.
• K. Rustan M. Leino,Arnd Poetzsch-Heffter,Yunhong Zhou,Using Data Groups to Specify and Check Side Effects.
• Zoran Budimlic,Keith D. Cooper,Timothy J. Harvey,Ken Kennedy,Timothy S. Oberg,Steven W. Reeves,Fast Copy Coalescing and Live-Range Identification.
• Seth Hallem,Benjamin Chelf,Yichen Xie,Dawson R. Engler,A System and Language for Building System-Specific, Static Analyses.
• G. Ramalingam,Alex Varshavsky,John Field,Deepak Goyal,Shmuel Sagiv,Deriving Specialized Program Analyses for Certifying Component-Client Conformance.
• Byoungro So,Mary W. Hall,Pedro C. Diniz,A Compiler Approach to Fast Hardware Design Space Exploration in FPGA-based Systems.
• Jeffrey S. Foster,Tachio Terauchi,Alexander Aiken,Flow-Sensitive Type Qualifiers.
• Manuel Fähndrich,Robert DeLine,Adoption and Focus: Practical Linear Types for Imperative Programming.
• Thomas A. Henzinger,Christoph M. Kirsch,The Embedded Machine: Predictable, Portable Real-Time Code.
• Jong-Deok Choi,Keunwoo Lee,Alexey Loginov,Robert O'Callahan,Vivek Sarkar,Manu Sridharan,Efficient and Precise Datarace Detection for Multithreaded Object-Oriented Programs.
• George S. Almasi,David A. Padua,MaJIC: Compiling MATLAB for Speed and Responsiveness.

2001

• Nevin Heintze,Olivier Tardieu,Demand-Driven Pointer Analysis.
• Simon Marlow,Simon L. Peyton Jones,Andrew Moran,John H. Reppy,Asynchronous Exceptions in Haskell.
• Chandra Krintz,Brad Calder,Using Annotation to Reduce Dynamic Optimization Time.
• Perry Cheng,Guy E. Blelloch,A Parallel, Real-Time Garbage Collector.
• William Thies,Frédéric Vivien,Jeffrey Sheldon,Saman P. Amarasinghe,A Unified Framework for Schedule and Storage Optimization.
• David R. Hanson,Todd A. Proebsting,Dynamic Variables.
• Thomas Ball,Rupak Majumdar,Todd D. Millstein,Sriram K. Rajamani,Automatic Predicate Abstraction of C Programs.
• William S. Evans,Christopher W. Fraser,Bytecode Compression via Profiled Grammar Rewriting.
• Sanjeev Kumar,Yitzhak Mandelbaum,Xiang Yu,Kai Li,ESP: A Language for Programmable Devices.
• David Gay,Alexander Aiken,Language Support for Regions.
• Matthew Arnold,Barbara G. Ryder,A Framework for Reducing the Cost of Instrumented Code.
• Jianxin Xiong,Jeremy R. Johnson,Robert W. Johnson,David A. Padua,SPL: A Language and Compiler for DSP Algorithms.
• Wolfram Amme,Niall Dalton,Michael Franz,Jeffery von Ronne,SafeTSA: A Type Safe and Referentially Secure Mobile-Code Representation Based on Static Single Assignment Form.
• Trishul M. Chilimbi,Efficient Representations and Abstractions for Quantifying and Exploiting Data Reference Locality.
• Michael W. Hicks,Jonathan T. Moore,Scott Nettles,Dynamic Software Updating.
• David F. Bacon,C. Richard Attanasio,Han Bok Lee,V. T. Rajan,Stephen E. Smith,Java without the Coffee Breaks: A Nonintrusive Multiprocessor Garbage Collector.
• Stefan Monnier,Bratin Saha,Zhong Shao,Principled Scavenging.
• Robert DeLine,Manuel Fähndrich,Enforcing High-Level Protocols in Low-Level Software.
• Andrew W. Appel,Lal George,Optimal Spilling for CISC Machines with Few Registers.
• Nevin Heintze,Olivier Tardieu,Ultra-fast Aliasing Analysis using CLA: A Million Lines of C Code in a Second.
• Ran Shaham,Elliot K. Kolodner,Shmuel Sagiv,Heap Profiling for Space-Efficient Java.
• Emery D. Berger,Benjamin G. Zorn,Kathryn S. McKinley,Composing High-Performance Memory Allocators.
• Siddhartha Chatterjee,Erin Parker,Philip J. Hanlon,Alvin R. Lebeck,Exact Analysis of the Cache Behavior of Nested Loops.
• Frédéric Vivien,Martin C. Rinard,Incrementalized Pointer and Escape Analysis.
• Rakesh Ghiya,Daniel M. Lavery,David C. Sehr,On the Importance of Points-to Analysis and Other Memory Disambiguation Methods for C Programs.
• Anders Møller,Michael I. Schwartzbach,The Pointer Assertion Logic Engine.
• Andrew Kennedy,Don Syme,Design and Implementation of Generics for the .NET Common Language Runtime.
• Eric Schnarr,Mark D. Hill,James R. Larus,Facile: A Language and Compiler for High-Performance Processor Simulators.
• Youtao Zhang,Rajiv Gupta,Timestamped Whole Program Path Representation and its Applications.
• Aneesh Aggarwal,Keith H. Randall,Related Field Analysis.

2000

• Steven Lucco,Split-stream dictionary program compression.
• Qing Yi,Vikram S. Adve,Ken Kennedy,Transforming loops to recursion for multi-level memory hierarchies.
• Erik Ruf,Effective synchronization removal for Java.
• Radu Rugina,Martin C. Rinard,Symbolic bounds analysis of pointers, array indices, and accessed memory regions.
• Ben-Chung Cheng,Wen-mei W. Hwu,Modular interprocedural pointer analysis using access paths: design, implementation, and evaluation.
• Allan Heydon,Roy Levin,Yuan Yu,Caching function calls using precise dependencies.
• Manuvir Das,Unification-based pointer analysis with directional assignments.
• Dante J. Cannarozzi,Michael P. Plezbert,Ron Cytron,Contaminated garbage collection.
• Christopher Colby,Peter Lee,George C. Necula,Fred Blau,Mark Plesko,Kenneth Cline,A certifying compiler for Java.
• Kent D. Wilken,Jack Liu,Mark Heffernan,Optimal instruction scheduling using integer programming.
• G. Ramalingam,On loops, dominators, and dominance frontier.
• Atanas Rountev,Satish Chandra,Off-line variable substitution for scaling points-to analysis.
• Cormac Flanagan,Stephen N. Freund,Type-based race detection for Java.
• Julian Dolby,Andrew A. Chien,An automatic object inlining optimization and its evaluation.
• Vasanth Bala,Evelyn Duesterwald,Sanjeev Banerjia,Dynamo: a transparent dynamic optimization system.
• Manuel Fähndrich,Jakob Rehof,Manuvir Das,Scalable context-sensitive flow analysis using instantiation constraints.
• Tamar Domani,Elliot K. Kolodner,Erez Petrank,A generational on-the-fly garbage collector for Java.
• Vugranam C. Sreedhar,Michael G. Burke,Jong-Deok Choi,A framework for interprocedural optimization in the presence of dynamic class loading.
• Yuan Lin,David A. Padua,Compiler analysis of irregular memory accesses.
• Zhichen Xu,Barton P. Miller,Thomas W. Reps,Safety checking of machine code.
• George C. Necula,Translation validation for an optimizing compiler.
• Mark Stephenson,Jonathan Babb,Saman P. Amarasinghe,Bitwidth analysis with application to silicon compilation.
• Zhanyong Wan,Paul Hudak,Functional reactive programming from first principles.
• Norman Ramsey,Simon L. Peyton Jones,A single intermediate language that supports multiple implementations of exceptions.
• Rastislav Bodík,Rajiv Gupta,Vivek Sarkar,ABCD: eliminating array bounds checks on demand.
• Bob Boothe,Efficient algorithms for bidirectional debugging.
• Javier Zalamea,Josep Llosa,Eduard Ayguadé,Mateo Valero,Improved spill code generation for software pipelined loops.
• Michal Cierniak,Guei-Yuan Lueh,James M. Stichnoth,Practicing JUDO: Java under dynamic optimizations.
• Sanjay Ghemawat,Keith H. Randall,Daniel J. Scales,Field analysis: getting useful and low-cost interprocedural information.
• Samuel Larsen,Saman P. Amarasinghe,Exploiting superword level parallelism with multimedia instruction sets.

1999

• Christopher W. Fraser,Todd A. Proebsting,Finite-Static Code Generation.
• Keith D. Cooper,Nathaniel McIntosh,Enhanced Code Compression for Embedded RISC Processors.
• Matteo Frigo,A Fast Fourier Transform Compiler.
• Guy E. Blelloch,Perry Cheng,On Bounding Time and Space for Multiprocessor Garbage Collection.
• Michael S. Schlansker,Scott A. Mahlke,Richard Johnson,Control CPR: A Branch Height Reduction Optimization for EPIC Architectures.
• Trishul M. Chilimbi,Mark D. Hill,James R. Larus,Cache-Conscious Structure Layout.
• Allen Leung,Lal George,Static Single Assignment Form for machine Code.
• Trishul M. Chilimbi,Bob Davidson,James R. Larus,Cache-Conscious Structure Definition.
• James R. Larus,Whole Program Paths.
• Steven R. Vegdahl,Using Node Merging to Enhance Graph Coloring.
• Radu Rugina,Martin C. Rinard,Pointer Analysis for Multithreaded Programs.
• Chen Ding,Ken Kennedy,Improving Cache Performance in Dynamic Applications through Data and Computation Reorganization at Run Time.
• Le-Chun Wu,Rajiv Mirani,Harish Patil,Bruce Olsen,Wen-mei W. Hwu,A New Framework for Debugging Globally Optimized Code.
• Jeffrey S. Foster,Manuel Fähndrich,Alexander Aiken,A Theory of Type Qualifiers.
• Kathleen Fisher,John H. Reppy,The Design of a Class Mechanism for Moby.
• Amit Rao,Santosh Pande,Storage Assignment Optimizations to Generate Compact and Efficient Code on Embedded DSPs.
• Suan Hsi Yong,Susan Horwitz,Thomas W. Reps,Pointer Analysis for Programs with Structures and Casting.
• Brian Grant,Matthai Philipose,Markus Mock,Craig Chambers,Susan J. Eggers,An Evaluation of Staged Run-Time Optimizations in DyC.
• Simon L. Peyton Jones,Alastair Reid,Fergus Henderson,C. A. R. Hoare,Simon Marlow,A Semantics for Imprecise Exceptions.
• Karl Crary,Robert Harper,Sidd Puri,What is a Recursive Module?
• Yonghong Song,Zhiyuan Li,New Tiling Techniques to Improve Cache Temporal Locality.
• Rastislav Bodík,Rajiv Gupta,Mary Lou Soffa,Load-Reuse Analysis: Design and Evaluation.
• James M. Stichnoth,Guei-Yuan Lueh,Michal Cierniak,Support for Garbage Collection at Every Instruction in a Java Compiler.
• Christopher W. Fraser,Automatic Inference of Models for Statistical Code Compression.
• Renaud Marlet,Charles Consel,Philippe Boinot,Efficient Incremental Run-Time Specialization for Free.
• William Pugh,Compressing Java Class Files.

1998

• Ali-Reza Adl-Tabatabai,Michal Cierniak,Guei-Yuan Lueh,Vishesh M. Parikh,James M. Stichnoth,Fast, Effective Code Generation in a Just-In-Time Java Compiler.
• Rastislav Bodík,Rajiv Gupta,Mary Lou Soffa,Complete Removal of Redundant Computations.
• Omri Traub,Glenn H. Holloway,Michael D. Smith,Quality and Speed in Linear-scan Register Allocation.
• S. Subramanya Sastry,Subbarao Palacharla,James E. Smith,Exploiting Idle Floating-Point Resources for Integer Execution.
• Peter F. Sweeney,Frank Tip,A Study of Dead Data Members in C++ Applications.
• Yingchun Zhu,Laurie J. Hendren,Communication Optimizations for Parallel C Programs.
• Amer Diwan,Kathryn S. McKinley,J. Eliot B. Moss,Type-Based Alias Analysis.
• Andrew Ayers,Stuart de Jong,John Peyton,Richard Schooler,Scalable Cross-Module Optimization.
• Matteo Frigo,Charles E. Leiserson,Keith H. Randall,The Implementation of the Cilk-5 Multithreaded Language.
• Rebecca Hasti,Susan Horwitz,Using Static Single Assignment Form to Improve Flow-Insensitive Pointer Analysis.
• Minghui Yang,Gang-Ryung Uh,David B. Whalley,Improving Performance by Branch Reordering.
• Vikram S. Adve,John M. Mellor-Crummey,Using Integer Sets for Data-Parallel Program Analysis and Optimization.
• Yunheung Paek,Jay Hoeflinger,David A. Padua,Simplification of Array Access Patterns for Compiler Optimizations.
• Fred C. Chow,Robert Kennedy,Shin-Ming Liu,Raymond Lo,Peng Tu,Register Promotion by Partial Redundancy Elimination of Loads and Stores.
• Perry Cheng,Robert Harper,Peter Lee,Generational Stack Collection and Profile-Driven Pretenuring.
• Fabrice Le Fessant,Ian Piumarta,Marc Shapiro,An Implementation for Complete, Asynchronous, Distributed Garbage Collection.
• Glenn Ammons,James R. Larus,Improving Data-flow Analysis with Path Profiles.
• E. Christopher Lewis,Calvin Lin,Lawrence Snyder,The Implementation and Evaluation of Fusion and Contraction in Array Languages.
• William D. Clinger,Proper Tail Recursion and Space Efficiency.
• David Gay,Alexander Aiken,Memory Management with Explicit Regions.
• George C. Necula,Peter Lee,The Design and Implementation of a Certifying Compiler.
• Philip Wickline,Peter Lee,Frank Pfenning,Run-time Code Generation and Modal-ML.
• Ole Agesen,David Detlefs,J. Eliot B. Moss,Garbage Collection and Local Variable Type-Precision and Liveness in Java Virtual Machines.
• Gabriel Rivera,Chau-Wen Tseng,Data Transformations for Eliminating Conflict Misses.
• David F. Bacon,Ravi B. Konuru,Chet Murthy,Mauricio J. Serrano,Thin Locks: Featherweight Synchronization for Java.
• Ian Piumarta,Fabio Riccardi,Optimizing Direct-threaded Code by Selective Inlining.
• Matthew Flatt,Matthias Felleisen,Units: Cool Modules for HOT Languages.
• Christopher Colby,Patrice Godefroid,Lalita Jategaonkar Jagadeesan,Automatically Closing Open Reactive Programs.
• Manuel Fähndrich,Jeffrey S. Foster,Zhendong Su,Alexander Aiken,Partial Online Cycle Elimination in Inclusion Constraint Graphs.
• Hongwei Xi,Frank Pfenning,Eliminating Array Bound Checking Through Dependent Types.
• A. V. S. Sastry,Roy Dz-Ching Ju,A New Algorithm for Scalar Register Promotion based on SSA Form.

1997

• Todd A. Proebsting,Simple Translation of Goal-Directed Evaluation.
• Cormac Flanagan,Matthias Felleisen,Componential Set-Based Analysis.
• Induprakas Kodukula,Nawaaz Ahmed,Keshav Pingali,Data-centric Multi-level Blocking.
• Glenn Ammons,Thomas Ball,James R. Larus,Exploiting Hardware Performance Counters with Flow and Context Sensitive Profiling.
• Adam Brooks Webber,Program Analysis Using Binary Relations.
• Rohit Chandra,Ding-Kai Chen,Robert Cox,Dror E. Maydan,Nenad Nedeljkovic,Jennifer-Ann M. Anderson,Data Distribution Support on Distributed Shared Memory Multiprocessors.
• Keith D. Cooper,John Lu,Register Promotion in C Programs.
• Massimiliano Poletto,Dawson R. Engler,M. Frans Kaashoek,tcc: A System for Fast, Flexible, and High-level Dynamic Code Generation.
• Jens Ernst,William S. Evans,Christopher W. Fraser,Steven Lucco,Todd A. Proebsting,Code Compression.
• Amir H. Hashemi,David R. Kaeli,Brad Calder,Efficient Procedure Mapping Using Cache Line Coloring.
• Eric Eide,Kevin Frei,Bryan Ford,Jay Lepreau,Gary Lindstrom,Flick: A Flexible, Optimizing IDL Compiler.
• Dirk Dussart,Rogardt Heldal,John Hughes,Module-Sensitive Program Specialisation.
• Christian S. Collberg,Reverse Interpretation + Mutation Analysis = Automatic Retargeting.
• Rastislav Bodík,Rajiv Gupta,Mary Lou Soffa,Interprocedural Conditional Branch Elimination.
• Alexandre E. Eichenberger,Edward S. Davidson,Efficient Formulation for Optimal Modulo Schedulers.
• Guei-Yuan Lueh,Thomas R. Gross,Call-Cost Directed Register Allocation.
• Andrew Ayers,Robert Gottlieb,Richard Schooler,Aggressive Inlining.
• Kenjiro Taura,Akinori Yonezawa,Fine-grain Multithreading with Minimal Compiler Support - A Cost Effective Approach to Implementing Efficient Multithreading Languages.
• David W. Goodwin,Interprocedural Dataflow Analysis in an Executable Optimizer.
• Pedro C. Diniz,Martin C. Rinard,Dynamic Feedback: An Effective Technique for Adaptive Computing.
• Peter Bergner,Peter Dahl,David Engebretsen,Matthew T. O'Keefe,Spill Code Minimization via Interference Region Spilling.
• Nevin Heintze,David A. McAllester,Linear-time Subtransitive Control Flow Analysis.
• Tim A. Wagner,Susan L. Graham,Incremental Analysis of real Programming Languages.
• Julian Dolby,Automatic Inline Allocation of Objects.
• Michael Sperber,Peter Thiemann,Two for the Price of One: Composing Partial Evaluation and Compilation.
• Jakob L. Jensen,Michael E. Jørgensen,Nils Klarlund,Michael I. Schwartzbach,Automatic Verification of Pointer Programs using Monadic Second-Order Logic.
• Fred C. Chow,Sun Chan,Robert Kennedy,Shin-Ming Liu,Raymond Lo,Peng Tu,A New Algorithm for Partial Redundancy Elimination based on SSA Form.
• Rastislav Bodík,Rajiv Gupta,Partial Dead Code Elimination using Slicing Transformations.
• G. Ramalingam,Harini Srinivasan,A Member Lookup Algorithm for C++.
• Cliff Young,David S. Johnson,David R. Karger,Michael D. Smith,Near-optimal Intraprocedural Branch Alignment.
• William D. Clinger,Lars Thomas Hansen,Generational Garbage Collection and the Radioactive Decay Model.

1996

• Satish Chandra,Brad Richards,James R. Larus,Teapot: Language Support for Writing Memory Coherence Protocols.
• G. Ramalingam,Data Flow Frequency Analysis.
• David Evans,Static Detection of Dynamic Memory Errors.
• Vugranam C. Sreedhar,Guang R. Gao,Yong-Fong Lee,A New Framework for Exhaustive and Incremental Data Flow Analysis Using DJ Graphs.
• Philip W. Trinder,Kevin Hammond,James S. Mattson Jr.,A. S. Partridge,Simon L. Peyton Jones,GUM: A Portable Parallel Implementation of Haskell.
• Robert G. Burger,R. Kent Dybvig,Printing Floating-Point Numbers Quickly and Accurately.
• Martin C. Rinard,Pedro C. Diniz,Commutativity Analysis: A New Analysis Framework for Parallelizing Compilers.
• Gianfranco Bilardi,Keshav Pingali,Generalized Dominance and Control Dependence.
• Ali-Reza Adl-Tabatabai,Thomas R. Gross,Source-Level Debugging of Scalar Optimized Code.
• David Tarditi,J. Gregory Morrisett,Perry Cheng,Christopher A. Stone,Robert Harper,Peter Lee,TIL: A Type-Directed Optimizing Compiler for ML.
• John C. Ruttenberg,Guang R. Gao,Woody Lichtenstein,Artour Stoutchinin,Software Pipelining Showdown: Optimal vs. Heuristic Methods in a Production Compiler.
• Carl Bruggeman,Oscar Waddell,R. Kent Dybvig,Representing Control in the Presence of One-Shot Continuations.
• Michael Sperber,Peter Thiemann,Realistic Compilation by Partial Evaluation.
• Peter Lee,Mark Leone,Optimizing ML with Run-Time Code Generation.
• Todd B. Knoblock,Erik Ruf,Data Specialization.
• Norman Ramsey,Relocating Machine Instructions by Currying.
• Mark W. Bailey,Jack W. Davidson,Target-Sensitive Construction of Diagnostic Programs for Procedure Calling Sequence Generators.
• Dawson R. Engler,VCODE: a Retargetable, Extensible, Very Fast Dynamic Code Generation System.
• Joel Auslander,Matthai Philipose,Craig Chambers,Susan J. Eggers,Brian N. Bershad,Fast, Effective Dynamic Compilation.
• Soumen Chakrabarti,Manish Gupta,Jong-Deok Choi,Global Communication Analysis and Optimization.
• Steven Dawson,C. R. Ramakrishnan,David Scott Warren,Practical Program Analysis Using General Purpose Logic Programming Systems - A Case Study.
• John H. Reppy,Jon G. Riecke,Simple Objects for Standard ML.
• Mark Russinovich,Bryce Cogswell,Replay For Concurrent Non-Deterministic Shared Memory Applications.
• Suresh Jagannathan,Andrew K. Wright,Flow-directed Inlining.
• Hans-Juergen Boehm,Simple Garbage-Collector-Safety.
• Cormac Flanagan,Matthew Flatt,Shriram Krishnamurthi,Stephanie Weirich,Matthias Felleisen,Static Debugging: Browsing the Web of Program Invariants.
• Ali-Reza Adl-Tabatabai,Geoff Langdale,Steven Lucco,Robert Wahbe,Efficient and Language-Independent Mobile Programs.
• Alexandre E. Eichenberger,Edward S. Davidson,A Reduced Multipipeline Machine Description that Preserves Scheduling Constraints.

1995

• M. Anton Ertl,Stack Caching for Interpreters.
• Brad Calder,Dirk Grunwald,Donald C. Lindsay,James H. Martin,Michael Mozer,Benjamin G. Zorn,Corpus-Based Static Branch Prediction.
• Erik Ruf,Context-Insensitive Alias Analysis Reconsidered.
• Arvind Krishnamurthy,Katherine A. Yelick,Optimizing Parallel Programs with Explicit Synchronization.
• Priyadarshan Kolte,Michael Wolfe,Elimination of Redundant Array Subscript Range Checks.
• Stan Y. Liao,Srinivas Devadas,Kurt Keutzer,Steven W. K. Tjiang,Albert R. Wang,Storage Assignment to Decrease Code Size.
• Robert G. Burger,Oscar Waddell,R. Kent Dybvig,Register Allocation Using Lazy Saves, Eager Restores, and Greedy Shuffling.
• Stephanie Coleman,Kathryn S. McKinley,Tile Size Selection Using Cache Organization and Data Layout.
• Jack L. Lo,Susan J. Eggers,Improving Balanced Scheduling with Compiler Optimizations that Increase Instruction-Level Parallelism.
• Keshav Pingali,Gianfranco Bilardi,APT: A Data Structure for Optimal Control Dependence Computation.
• Alexander Aiken,Manuel Fähndrich,Raph Levien,Better Static Memory Management: Improving Region-Based Analysis of Higher-Order Languages.
• Peng Tu,David A. Padua,Efficient Building and Placing of Gating Functions.
• Pascalin Amagbégnon,Loïc Besnard,Paul Le Guernic,Implementation of the Data-Flow Synchronous Language SIGNAL.
• Lawrence Rauchwerger,David A. Padua,The LRPD Test: Speculative Run-Time Parallelization of Loops with Privatization and Reduction Parallelization.
• Frank Mueller,David B. Whalley,Avoiding Conditional Branches by Code Replication.
• Mary F. Fernandez,Simple and Effective Link-Time Optimization of Modula-3 Programs.
• Erik R. Altman,Ramaswamy Govindarajan,Guang R. Gao,Scheduling and Mapping: Software Pipelining in the Presence of Structural Hazards.
• Jeffrey Dean,Craig Chambers,David Grove,Selective Specialization for Object-Oriented Languages.
• Jason R. C. Patterson,Accurate Static Branch Prediction by Value Range Propagation.
• James R. Larus,Eric Schnarr,EEL: Machine-Independent Executable Editing.
• Michal Cierniak,Wei Li,Unifying Data and Control Transformations for Distributed Shared Memory Machines.
• Paul R. Carini,Michael Hind,Flow-Sensitive Interprocedural Constant Propagation.
• Gagan Agrawal,Joel H. Saltz,Raja Das,Interprocedural Partial Redundancy Elimination and its Application to Distributed Memory Compilation.
• Cliff Click,Global Code Motion / Global Value Mumbering.
• Zhong Shao,Andrew W. Appel,A Type-Based Compiler for Standard ML.
• Jens Knoop,Oliver Rüthing,Bernhard Steffen,The Power of Assignment Motion.
• David A. Barrett,Benjamin G. Zorn,Garbage Collection Using a Dynamic Threatening Boundary.

1994

• Kemal Ebcioglu,Randy D. Groves,Ki-Chang Kim,Gabriel M. Silberman,Isaac Ziv,VLIW Compilation Techniques in a Superscalar Environment.
• Amr Sabry,Matthias Felleisen,Is Continuation-Passing Useful for Data Flow Analysis?
• Amitabh Srivastava,David W. Wall,Link-Time Optimization of Address Calculation on a 64-bit Architecture.
• Reinhard von Hanxleden,Ken Kennedy,GIVE-N-TAKE - A Balanced Code Placement Framework.
• Jens Knoop,Oliver Rüthing,Bernhard Steffen,Partial Dead Code Elimination.
• Joseph Hummel,Laurie J. Hendren,Alexandru Nicolau,A General Data Dependence Test for Dynamic, Pointer-Based Data Structures.
• Vivek Sarkar,Barbara G. Ryder,Mary Lou Soffa,Proceedings of the ACM SIGPLAN'94 Conference on Programming Language Design and Implementation (PLDI), Orlando, Florida, USA, June 20-24, 1994.
• Maryam Emami,Rakesh Ghiya,Laurie J. Hendren,Context-Sensitive Interprocedural Points-to Analysis in the Presence of Function Pointers.
• Steven M. Kurlander,Charles N. Fischer,Zero-cost Range Splitting.
• William Pugh,Counting Solutions to Presburger Formulas: How and Why.
• Richard Johnson,David Pearson,Keshav Pingali,The Program Structure Tree: Computing Control Regions in Linear Time.
• Roland Wismüller,Debugging of Globally Optimized Programs Using Data Flow Analysis.
• Pascal Van Hentenryck,Viswanath Ramachandran,Backtracking without Trailing in CLP(RLin).
• Cindy Norris,Lori L. Pollock,register Allocation over the Program Dependence Graph.
• Preston Briggs,Keith D. Cooper,Effective Partial Redundancy Elimination.
• Ko-Yang Wang,Precise Compile-Time Performance Prediction for Superscalar-Based Computers.
• Jack W. Davidson,Sanjay Jinturkar,Memory Access Coalescing: A technique for Eliminating Redundant memory Accesses.
• Allan L. Fisher,Anwar M. Ghuloum,Parallelizing Complex Scans and Reductions.
• Tim A. Wagner,Vance Maverick,Susan L. Graham,Michael A. Harrison,Accurate Static Estimators for Program Optimization.
• Andrew W. Appel,David B. MacQueen,Separate Compilation for Standard ML.
• Torbjörn Granlund,Peter L. Montgomery,Division by Invariant Integers using Multiplication.
• Hiralal Agrawal,On Slicing Programs with Jump Statements.
• Robert H. B. Netzer,Mark H. Weaver,Optimal Tracing and Incremental Reexecution for Debugging Long-Running Programs.
• Alain Deutsch,Interprocedural May-Alias Analysis for Pointers: Beyond k-limiting.
• Todd M. Austin,Scott E. Breach,Gurindar S. Sohi,Efficient Detection of All Pointer and Array Access Errors.
• John Launchbury,Simon L. Peyton Jones,Lazy Functional State Threads.
• Andreas Krall,Improving Semi-static Branch Prediction by Code Replication.
• Mark B. Reinhold,Cache Performance of Garbage-Collected Programs.
• Pascal Van Hentenryck,Agostino Cortesi,Baudouin Le Charlier,Type Analysis of Prolog Using Type Graphs.
• Urs Hölzle,David Ungar,Optimizing Dynamically-Dispatched Calls with Run-Time Type Feedback.
• Amitabh Srivastava,Alan Eustace,ATOM - A System for Building Customized Program Analysis Tools.

1993

• Dirk Grunwald,Benjamin G. Zorn,Robert Henderson,Improving the Cache Locality of Memory Allocation.
• Saman P. Amarasinghe,Monica S. Lam,Communication Optimization and Code Generation for Distributed Memory Machines.
• Cormac Flanagan,Amr Sabry,Bruce F. Duba,Matthias Felleisen,The Essence of Compiling with Continuations.
• Ron Cytron,Reid Gershbein,Efficient Accomodation of May-Alias Information in SSA Form.
• Norman Adams,Pavel Curtis,Mike Spreitzer,First-Class Data-Type Representations in SchemeXerox.
• Robert Wahbe,Steven Lucco,Susan L. Graham,Practical Data Breakpoints: Design and Implementation.
• Daniel R. Kerns,Susan J. Eggers,Balanced Scheduling: Instruction Scheduling When Memory Latency is Uncertain.
• Richard A. Huff,Lifetime-Sensitive Modulo Scheduling.
• Seongsoo Hong,Richard Gerber,Compiling Real-Time Programs into Schedulable Code.
• Dorai Sitaram,Handling Control.
• Shlomit S. Pinter,Register Allocation with Instruction Scheduling: A New Approach.
• R. Kent Dybvig,Carl Bruggeman,David Eby,Guardians in a Generation-Based Garbage Collector.
• Priyadarshan Kolte,Mary Jean Harrold,Load/Store Range Analysis for Global Register Allocation.
• Evelyn Duesterwald,Rajiv Gupta,Mary Lou Soffa,A Practical Data Flow Framework for Array Reference Analysis and its Use in Optimizations.
• Nancy J. Warter,Scott A. Mahlke,Wen-mei W. Hwu,B. Ramakrishna Rau,Reverse If-Conversion.
• William Landi,Barbara G. Ryder,Sean Zhang,Interprocedural Side Effect Analysis With Pointer Aliasing.
• Susan L. Graham,Steven Lucco,Oliver Sharp,Orchestrating Interactions Among Parallel Computations.
• Daniel Weise,Roger F. Crew,Programmable Syntax Macros.
• Ali-Reza Adl-Tabatabai,Thomas R. Gross,Detection and Recovery of Endangered Variables Caused by Instruction Scheduling.
• Mickey R. Boyd,David B. Whalley,Isolation and Analysis of Optimization Errors.
• Dan Grove,Linda Torczon,Interprocedural Constant Propagation: A Study of Jump Function Implementations.
• Jennifer-Ann M. Anderson,Monica S. Lam,Global Optimizations for Parallelism and Locality on Scalable Parallel Machines.
• David A. Barrett,Benjamin G. Zorn,Using Lifetime Predictors to Improve Memory Allocation Performance.
• John Peterson,Mark P. Jones,Implementing Type Classes.
• Richard Johnson,Keshav Pingali,Dependence-Based Program Analysis.
• François Bourdoncle,Abstract Debugging of Higher-Order Imperative Languages.
• Scott Nettles,James O'Toole,Real-Time Replication Garbage Collection.
• Thomas Ball,James R. Larus,Branch Prediction For Free.
• Hans-Juergen Boehm,Space Efficient Conservative Garbage Collection.

1992

• Rok Sosic,Dynascope: A Tool for Program Directing.
• Todd A. Proebsting,Simple and Efficient BURS Table Generation.
• William Pugh,David Wonnacott,Eliminating False Data Dependences using the Omega Test.
• Dhananjay M. Dhamdhere,Barry K. Rosen,F. Kenneth Zadeck,How to Analyze Large Programs Efficiently and Informatively.
• Torbjörn Granlund,Richard Kenner,Eliminating Branches using a Superoptimizer and the GNU C Compiler.
• Amer Diwan,J. Eliot B. Moss,Richard L. Hudson,Compiler Support for Garbage Collection in a Statically Typed Language.
• Joxan Jaffar,Spiro Michaylov,Peter J. Stuckey,Roland H. C. Yap,An Abstract Machine for CLP(R).
• Todd A. Proebsting,Charles N. Fischer,Probalistic Register Allocation.
• David B. Wortman,Michael D. Junkin,A Concurrent Compiler for Modula-2+.
• Michael Wolfe,Beyond Induction Variables.
• Steven W. K. Tjiang,John L. Hennessy,Sharlit - A Tool for Building Optimizers.
• Frank Mueller,David B. Whalley,Avoiding Unconditional Jumps by Code Replication.
• Preston Briggs,Keith D. Cooper,Linda Torczon,Rematerialization.
• Reinhard von Hanxleden,Ken Kennedy,Relaxing SIMD Control Flow Constraints using Loop Transformations.
• Jichang Tan,I-Peng Lin,Compiling Dataflow Analysis of Logic Programs.
• Vadim Maslov,Delinearization: An Efficient Way to Break Multiloop Dependence Equations.
• William Landi,Barbara G. Ryder,A Safe Approximate Algorithm for Interprocedural Pointer Aliasing.
• Kazuhiro Ogata,Satoshi Kurihara,Mikio Inari,Norihisa Doi,The Design and Implementation of HoME.
• Suresh Jagannathan,James Philbin,A Customizable Substrate for Concurrent Languages.
• Jens Knoop,Oliver Rüthing,Bernhard Steffen,Lazy Code Motion.
• Young Gil Park,Benjamin Goldberg,Escape Analysis on Lists.
• Laurie J. Hendren,Joseph Hummel,Alexandru Nicolau,Abstractions for Recursive Pointer Data Structures: Improving the Analysis of Imperative Programs.
• B. Ramakrishna Rau,Meng Lee,Parthasarathy P. Tirumalai,Michael S. Schlansker,Register Allocation for Software Pipelined Loops.
• Vivek Sarkar,Radhika Thekkath,A General Framework for Iteration-Reordering Loop Transformations.
• Marina C. Chen,James R. Cowie,Prototyping Fortran-90 Compilers for Massively Parallel Machines.
• Roger Hoover,Alphonse: Incremental Computation as a Programming Abstraction.
• Urs Hölzle,Craig Chambers,David Ungar,Debugging Optimized Code with Dynamic Deoptimization.
• Norman Ramsey,David R. Hanson,A Retargetable Debugger.
• Gary Brooks,Gilbert J. Hansen,Steve Simmons,A New Approach to Debugging Optimized Code.
• Steven Lucco,A Dynamic Scheduling Technique for Irregular Parallel Programs.

1991

• Benjamin Goldberg,Tag-Free Garbage Collection for Strongly Typed Programming Languages.
• Gina Goff,Ken Kennedy,Chau-Wen Tseng,Practical Dependence Testing.
• Charles Consel,Siau-Cheng Khoo,Parameterized Partial Evaluation.
• G. A. Venkatesh,The Semantic Approach to Program Slicing.
• Robert Cartwright,Mike Fagan,Soft Typing.
• Tim Freeman,Frank Pfenning,Refinement Types for ML.
• Suneel Jain,Circular Scheduling: A New Technique to Perform Software Pipelining.
• William Pugh,Advice to Authors of Extended Abstracts.
• David Bernstein,Michael Rodeh,Global Instruction Scheduling for Superscalar Machines.
• Deborah Whitfield,Mary Lou Soffa,Automatic Generation of Global Optimizers.
• Amir Kishon,Paul Hudak,Charles Consel,Monitoring Semantics: A Formal Framework for Specifying, Implementing, and Reasoning about Execution Monitors.
• Scott McFarling,Procedure Merging with Instruction Caches.
• Yves Bertot,Occurences in Debugger Specifications.
• Dror E. Maydan,John L. Hennessy,Monica S. Lam,Efficient and Exact Data Dependence Analysis.
• Michael E. Wolf,Monica S. Lam,A Data Locality Optimizing Algorithm.
• John Launchbury,Strictness and Binding-Time Analyses: Two for the Price of One.
• Hans-Juergen Boehm,Alan J. Demers,Scott Shenker,Mostly Parallel Garbage Collection.
• David W. Wall,Predicting Program Behavior Using Real or Estimated Profiles.
• David G. Bradlee,Robert R. Henry,Susan J. Eggers,The Marion System for Retargetable Instruction Scheduling.
• Todd A. Proebsting,Charles N. Fischer,Linear-Time, Optimal Code Scheduling for Delayed-Load Architectures.
• Paul R. Wilson,Michael S. Lam,Thomas G. Moher,Effective ``Static-Graph'' Reorganization to Improve Locality in Garbage-Collected Systems.
• Peter Fritzson,Tibor Gyimóthy,Mariam Kamkar,Nahid Shahmehri,Generalized Algorithmic Debugging and Testing.
• Guang R. Gao,Yue-Bong Wong,Qi Ning,A Timed Petri-Net Model for Fine-Grain Loop Scheduling.
• David Callahan,Brian Koblenz,Register Allocation via Hierarchical Graph Coloring.
• W. G. Morris,CCG: A Prototype Coagulating Code Generator.
• John H. Reppy,CML: A Higher-Order Concurrent Language.
• Joxan Jaffar,Spiro Michaylov,Roland H. C. Yap,A Methodology for Managing Hard Constraints in CLP Systems.
• Mark Bromley,Steven Heller,Timothy S. McNerney,Guy L. Steele Jr.,Fortran at Ten Gigaflops: The Connection Machine Convolution Compiler.
• Siddhartha Chatterjee,Guy E. Blelloch,Allan L. Fisher,Size and Access Inference for Data-Parallel Programs.

1990

• Peter B. Kessler,Fast Breakpoints: Design and Implementation.
• Saumya K. Debray,Nai-Wei Lin,Manuel V. Hermenegildo,Task Granularity Analysis in Logic Programs.
• Vivek Sarkar,Instruction Reordering for Fork-Join Parallelism.
• Brian R. Nickerson,Graph Coloring Register Allocation for Processors with Multi-Register Operands.
• David Callahan,Steve Carr,Ken Kennedy,Improving Register Allocation for Subscripted Variables.
• Vatsa Santhanam,Daryl Odnert,Register Allocation Across Procedure and Module Boundaries.
• Hiralal Agrawal,Joseph Robert Horgan,Dynamic Program Slicing.
• Ping-Sheng Tseng,Compiling Programs for a Linear Systolic Array.
• Robert Giegerich,On the Structure of Verifiable Code Generator Specifications.
• Robert R. Henry,Kenneth M. Whaley,Bruce Forstall,The University of Washington Illustrating Compiler.
• Vernon A. Lee Jr.,Hans-Juergen Boehm,Optimizing Programs over the Constructive Reals.
• Karl Pettis,Robert C. Hansen,Profile Guided Code Positioning.
• Robert Hieb,R. Kent Dybvig,Carl Bruggeman,Representing Control in the Presence of First-Class Continuations.
• William D. Clinger,How to Read Floating-Point Numbers Accurately.
• Gordon V. Cormack,Andrew K. Wright,Type-Dependent Parameter Inference.
• William Pugh,Grant E. Weddell,Two-Directional Record Layout for Multiple Inheritance.
• Thanasis Mitsolides,Malcolm Harrison,Generators and the Replicator Control Structures in the Parallel Environment of ALLOY.
• Craig Chambers,David Ungar,Iterative Type Analysis and Extended Message Splitting: Optimizing Dynamically-Typed Object-Oriented Programs.
• Dean Jacobs,Type Declarations as Subtype Constraints in Logic Programming.
• Martin Jourdan,Didier Parigot,Catherine Julié,Olivier Durin,Carole Le Bellec,Design, Implementation and Evaluation of the FNC-2 Attribute Grammar System.
• Susan Horwitz,Identifying the Semantic and Textual Differences Between Two Versions of a Program.
• Ron Cytron,Jeanne Ferrante,Vivek Sarkar,Compact Representations for Control Dependence.
• Steven Anderson,Paul Hudak,Compilation of Haskell Array Comprehensions for Scientific Computing.
• Guy L. Steele Jr.,Jon L. White,How to Print Floating-Point Numbers Accurately.
• Rajiv Gupta,A Fresh Look at Optimizing Array Bound Checking.
• Alan L. Wendt,Fast Code Generation Using Automatically-Generated Decision Trees.
• Robert A. Ballance,Arthur B. Maccabe,Karl J. Ottenstein,The Program Dependence Web: A Representation Supporting Control, Data, and Demand-Driven Interpretation of Imperative Languages.
• Tim Teitelbaum,Richard Chapman,Higher-Order Attribute Grammars and Editing Environments.
• Zahira Ammarguellat,Williams Ludwell Harrison III,Automatic Recognition of Induction Variables and Recurrence Relations by Abstract Interpretation.
• David R. Chase,Mark N. Wegman,F. Kenneth Zadeck,Analysis of Pointers and Structures.

1989

• Rajiv Gupta,Mary Lou Soffa,Tim Steele,Register Allocation via Clique Separators.
• G. A. Venkatesh,A Framework for Construction and Evaluation of High-Level Specifications for Program Analysis Techniques.
• Susan Horwitz,Phil Pfeiffer,Thomas W. Reps,Dependence Analysis for Pointer Variables.
• Russell R. Atkinson,Alan J. Demers,Carl Hauser,Christian Jacobi,Peter Kessler,Mark Weiser,Experiences Creating a Portable Cedar.
• Vivek Sarkar,Determining Average Program Execution Times and their Variance.
• Philip J. Koopman Jr.,Peter Lee,A Fresh Look at Combinator Graph Reduction.
• Thomas R. Gross,Angelika Zobel,Markus Zolg,Parallel Compilation for a Parallel Machine.
• Benjamin Goldberg,Generational Reference Counting: A Reduced-Communication Distributed Storage Reclamation Scheme.
• Anne Rogers,Keshav Pingali,Process Decomposition Through Locality of Reference.
• Helmut Emmelmann,Friedrich-Wilhelm Schröer,Rudolf Landwehr,BEG - A Generator for Efficient Back Ends.
• Robert Cartwright,Matthias Felleisen,The Semantics of Program Dependence.
• Harald Vogt,S. Doaitse Swierstra,Matthijs F. Kuiper,Higher-Order Attribute Grammars.
• Gordon V. Cormack,An LR Substring Parser for Noncorrecting Syntax Error Recovery.
• Waldemar Horwat,Andrew A. Chien,William J. Dally,Experience with CST: Programming and Implementation.
• Preston Briggs,Keith D. Cooper,Ken Kennedy,Linda Torczon,Coloring Heuristics for Register Allocation.
• Pierre Jouvelot,David K. Gifford,Reasoning about Continuations with Control Effects.
• David Bernstein,Dina Q. Goldin,Martin Charles Golumbic,Hugo Krawczyk,Yishay Mansour,Itai Nahshon,Ron Y. Pinter,Spill Code Minimization Techniques for Optimizing Compilers.
• Rodney Farrow,Alec G. Stanculescu,A VHDL Compiler Based on Attribute Grammar Methodology.
• Paul R. Wilson,Thomas G. Moher,Demonic Memories for Process Histories.
• David A. Kranz,Robert H. Halstead Jr.,Eric Mohr,Mul-T: A High-Performance Parallel Lisp.
• Wen-mei W. Hwu,Pohua P. Chang,Inline Function Expansion for Compiling C Programs.
• James O'Toole,David K. Gifford,Type Reconstruction with First-Class Polymorphic Values.
• Chi-Hung Chi,Henry G. Dietz,Unified Management of Registers and Cache Using Liveness and Cache Bypass.
• Hans-Juergen Boehm,Type Inference in the Presence of Type Abstraction.
• Vasanth Balasundaram,Ken Kennedy,A Technique for Summarizing Data Access and Its Use in Parallelism Enhancing Transformations.
• Edith Schonberg,On-The-Fly Detection of Access Anomalies.
• Craig Chambers,David Ungar,Customization: Optimizing Compiler Technology for SELF, A Dynamically-Typed Object-Oriented Programming Language.
• Daniel J. Salomon,Gordon V. Cormack,Scannerless NSLR(1) Parsing of Programming Languages.
• Jan Heering,Paul Klint,J. Rekers,Incremental Generation of Parsers.
• Ron Cytron,Michael Hind,Wilson C. Hsieh,Automatic Generation of DAG Parallelism.
• Christopher W. Fraser,A Language for Writing Code Generators.

1988

• Robert A. Ballance,Jacob Butcher,Susan L. Graham,Grammatical Abstraction and Incremental Syntax Analysis in a Language-Based Editor.
• Suneel Jain,Carol L. Thompson,An Efficient Approach to Data Flow Analysis in a Multi Pass Global Optimizer.
• Joseph Pallas,David Ungar,Multiprocessor Smalltalk: A Case Study of a Multiprocessor-Based Programming Environment.
• Janet A. Walz,Gregory F. Johnson,Incremental Evaluation for a General Class of Circular Attribute Grammars.
• J. L. Weiner,S. Ramakrishnan,A Piggy-back Compiler For Prolog.
• David W. Wall,Register Windows versus Register Allocation.
• Fred C. Chow,Minimizing Register Usage Penalty at Procedure Calls.
• Frank Pfenning,Conal Elliott,Higher-Order Abstract Syntax.
• John R. Rose,Refined Types: Highly Differentiated Type Systems and Their Use in the Design of Intermediate Langages.
• Susan Horwitz,Thomas W. Reps,David Binkley,Interprocedural Slicing Using Dependence Graphs.
• David R. Chase,Safety Considerations for Storage Allocation Optimizations.
• Uwe F. Pleban,Peter Lee,An Automatically Generated, Realistic Compiler for an Imperative Programming Language.
• Olin Shivers,Control-Flow Analysis in Scheme.
• Janice M. Stone,Debugging Concurrent Processes: A Case Study.
• Monica S. Lam,Software Pipelining: An Effective Scheduling Technique for VLIW Machines.
• Alexander Aiken,Alexandru Nicolau,Optimal Loop Parallelization.
• Daniel M. Yellin,Robert E. Strom,INC: A Language for Incremental Computations.
• James R. Larus,Paul N. Hilfinger,Detecting Conflicts Between Structure Accesses.
• Deborah S. Coutant,Sue Meloy,Michelle Ruscetta,DOC: A Practical Approach to Source-Level Debugging of Globally Optimized Code.
• Randy Allen,Steve Johnson,Compiling C for Vectorization, Parallelization, and Inline Expansion.
• Christopher W. Fraser,Alan L. Wendt,Automatic Generation of Fast Optimizing Code Generators.
• Barbara Liskov,Liuba Shrira,Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems.
• Saumya K. Debray,Unfold/Fold Transformations and Loop Optimization of Logic Programs.
• V. Seshadri,David B. Wortman,Michael D. Junkin,S. Weber,C. P. Yu,I. Small,Semantic Analysis in a Concurrent Compiler.
• Manuel E. Benitez,Jack W. Davidson,A Portable Global Optimizer and Linker.
• Birgit Schwarz,Walter Kirchgässner,Rudolf Landwehr,An Optimizer for Ada - Design, Experiences and Results.
• Barton P. Miller,Jong-Deok Choi,A Mechanism for Efficient Debugging of Parallel Programs.
• John H. Reppy,Synchronous Operations as First-Class Values.
• David Callahan,The Program Summary Graph and Flow-Sensitive InterproceduralData Flow Analysis.
• Kristy Andrews,Robert R. Henry,Wayne K. Yamamoto,Design and Implementation of the UW Illustrated Compiler.
• Andrew W. Appel,John R. Ellis,Kai Li,Real-Time Concurrent Collection on Stock Multiprocessors.
• Kurt Keutzer,Wayne Wolf,Anatomy of a Hardware Compiler.
• Keith D. Cooper,Ken Kennedy,Interprocedural Side-Effect Analysis in Linear Time.

1987

• Kai Koskimies,Jukka Paakki,TOOLS: a unifying approach to object-oriented language interpretation.
• James R. Cordy,T. C. Nicholas Graham,Design of an interpretive environment for Turing.
• Gregory F. Johnson,GL-a denotational testbed with continuations and partial continuations as first-class objects.
• Phil Kearns,Chris Cipriani,Mitzi Freeman,CCAL: An interpreted language for experimentation in concurrent control.
• Antony A. Faustini,William W. Wadge,An eductive interpreter for Lucid.
• Benjamin B. Chase,Robert T. Hood,Selective interpretation as a technique for debugging computationally intensive programs.
• Rolf Bahlke,Bernhard Moritz,Gregor Snelting,A generator for language-specific debugging systems.
• Bernard Lang,Francis Dupont,Incremental incrementally compacting garbage collection.
• Hans-Juergen Boehm,Constructive real interpretation of numerical programs.
• A. Jefferson Offutt,K. N. King,A Fortran 77 interpreter for mutation analysis.
• Stephen K. Skedzielewski,Robert Kim Yates,R. R. Oldehoeft,DI: an interactive debugging interpreter for applicative languages.
• Christopher F. Clark,The JADE interpreter: a RISC interpreter for syntax directed editing.
• Miquel Huguet,Tomás Lang,Yuval Tamir,A block-and-actions generator as an alternative to a simulator for collecting architecture measurements.
• Janalee O'Bagy,Ralph E. Griswold,A recursive interpreter for the Icon programming language.
• Raghu Karinthi,Mark Weiser,Incremental re-execution of programs.
• Jonas Barklund,Efficient interpretation of Prolog programs.
• Richard L. Wexelblat,Cathy May,Mimic: a fast system/370 simulator.
• Arch D. Robison,The Illinois functional programming interpreter.
• Henry Harr,Martha W. Evens,James Sprowl,Interpreting ABF - a language for document construction.
• Richard C. Waters,Efficient interpretation of synchronizable series expressions.
• Andreas Krall,Implementation of a high-speed Prolog interpreter.
• Stan Shebs,Robert R. Kessler,Automatic design and implementation of language data types.
• David Notkin,William G. Griswold,Enhancement through extension: the extension interpreter.
• J. Eliot B. Moss,Managing stack frames in Smalltalk.
• David Gelernter,Suresh Jagannathan,Thomas London,Parallelism, persistence and meta-cleanliness in the symmetric Lisp interpreter.
• Robert S. Sutor,Richard D. Jenks,The type inference and coercion facilities in the scratchpad II interpreter.
• Jack W. Davidson,Joseph V. Gresh,Cint: a RISC interpreter for the C programming language.
• J. Dana Eckart,Richard J. LeBlanc,Distributed garbage collection.
• Olivier Danvy,Memory allocation and higher-order functions.