2014

• Terence Parr,Sam Harwell,Kathleen Fisher,Adaptive LL(*) parsing: the power of dynamic analysis.
• Mingzhou Zhou,Xipeng Shen,Yaoqing Gao,Graham Yiu,Space-efficient multi-versioning for input-adaptive feedback-driven program optimizations.
• Ankush Desai,Pranav Garg,P. Madhusudan,Natural proofs for asynchronous programs using almost-synchronous reductions.
• Keval Vora,Sai Charan Koduru,Rajiv Gupta,ASPIRE: exploiting asynchronous parallelism in iterative algorithms using a relaxed consistency based DSM.
• Peng Wang,Santiago Cuellar,Adam Chlipala,Compiler verification meets cross-language linking via data abstraction.
• Manohar Jonnalagedda,Thierry Coppey,Sandro Stucki,Tiark Rompf,Martin Odersky,Staged parser combinators for efficient data processing.
• Chun-Hung Hsiao,Michael J. Cafarella,Satish Narayanasamy,Using web corpus statistics for program analysis.
• Ralf Mitschke,Sebastian Erdweg,Mirko Köhler,Mira Mezini,Guido Salvaneschi,i3QL: language-integrated live data views.
• Daniel W. Barowy,Dimitar Gochev,Emery D. Berger,CheckCell: data debugging for spreadsheets.
• Zhijia Zhao,Bo Wu,Mingzhou Zhou,Yufei Ding,Jianhua Sun,Xipeng Shen,Youfeng Wu,Call sequence prediction through probabilistic calling automata.
• Malavika Samak,Murali Krishna Ramanathan,Multithreaded test synthesis for deadlock detection.
• Henrique Nazaré,Izabela Maffra,Willer Santos,Leonardo Barbosa,Laure Gonnord,Fernando Magno Quintão Pereira,Validation of memory accesses through symbolic analyses.
• Richard Uhler,Nirav Dave,Smten with satisfiability-based search.
• Vineet Kumar,Laurie J. Hendren,MIX10: compiling MATLAB to X10 for high performance.
• Peng Liu,Omer Tripp,Xiangyu Zhang,Flint: fixing linearizability violations.
• Dhruva R. Chakrabarti,Hans-Juergen Boehm,Kumud Bhandari,Atlas: leveraging locks for non-volatile memory consistency.
• Cosmin Radoi,Stephen J. Fink,Rodric M. Rabbah,Manu Sridharan,Translating imperative code to MapReduce.
• Nicolás Rosner,Valeria S. Bengolea,Pablo Ponzio,Shadi Abdul Khalek,Nazareno Aguirre,Marcelo F. Frias,Sarfraz Khurshid,Bounded exhaustive test input generation from hybrid invariants.
• Florian David,Gaël Thomas,Julia Lawall,Gilles Muller,Continuously measuring critical section pressure with the free-lunch profiler.
• Sasa Misailovic,Michael Carbin,Sara Achour,Zichao Qi,Martin C. Rinard,Chisel: reliability- and accuracy-aware optimization of approximate computational kernels.
• Nada Amin,Tiark Rompf,Martin Odersky,Foundations of path-dependent types.
• Zvonimir Pavlinovic,Tim King,Thomas Wies,Finding minimum type error sources.
• Vlad Ureche,Eugene Burmako,Martin Odersky,Late data layout: unifying data representation transformations.
• Esteban Allende,Johan Fabry,Ronald Garcia,Éric Tanter,Confined gradual typing.
• Melanie Kambadur,Martha A. Kim,An experimental survey of energy management across the stack.
• Earl T. Barr,Mark Marron,Tardis: affordable time-travel debugging in managed runtimes.
• Keith Adams,Jason Evans,Bertrand Maher,Guilherme Ottoni,Andrew Paroski,Brett Simmers,Edwin Smith,Owen Yamauchi,The hiphop virtual machine.
• Luís Pina,Luís Veiga,Michael W. Hicks,Rubah: DSU for Java on a stock JVM.
• Qirun Zhang,Xiao Xiao,Charles Zhang,Hao Yuan,Zhendong Su,Efficient subcubic alias analysis for C.
• Asger Feldthaus,Anders Møller,Checking correctness of TypeScript interfaces for JavaScript libraries.
• Tian Xiao,Zhenyu Guo,Hucheng Zhou,Jiaxing Zhang,Xu Zhao,Chencheng Ye,Xi Wang,Wei Lin,Wenguang Chen,Lidong Zhou,Cybertron: pushing the limit on I/O reduction in data-parallel programs.
• Gustavo Pinto,Fernando Castor,Yu David Liu,Understanding energy behaviors of thread management constructs.
• Guy L. Steele Jr.,Doug Lea,Christine H. Flood,Fast splittable pseudorandom number generators.
• Thomas Bartenstein,Yu David Liu,Rate types for stream programs.
• Jonathan Bell,Gail E. Kaiser,Phosphor: illuminating dynamic data flow in commodity jvms.
• Tillmann Rendel,Jonathan Immanuel Brachthäuser,Klaus Ostermann,From object algebras to attribute grammars.
• Milos Gligoric,Wolfram Schulte,Chandra Prasad,Danny van Velzen,Iman Narasamdya,Benjamin Livshits,Automated migration of build scripts using dynamic analysis and search-based refactoring.
• Lucas Brutschy,Pietro Ferrara,Peter Müller,Static analysis for independent app developers.
• Linhai Song,Shan Lu,Statistical debugging for real-world performance problems.
• Esben Andreasen,Anders Møller,Determinacy in static analysis for jQuery.
• Jeffrey Bosboom,Sumanaruban Rajadurai,Weng-Fai Wong,Saman P. Amarasinghe,StreamJIT: a commensal compiler for high-performance stream programming.
• Emma Tosch,Emery D. Berger,SurveyMan: programming and automatically debugging surveys.
• Joscha Drechsler,Guido Salvaneschi,Ragnar Mogk,Mira Mezini,Distributed REScala: an update algorithm for distributed reactive programming.
• Tom Bergan,Dan Grossman,Luis Ceze,Symbolic execution of multithreaded programs from arbitrary program contexts.
• Brandon Holt,Preston Briggs,Luis Ceze,Mark Oskin,Alembic: automatic locality extraction via migration.
• Michael Pradel,Parker Schuh,George C. Necula,Koushik Sen,EventBreak: analyzing the responsiveness of user interfaces through performance-guided test generation.
• Nimrod Partush,Eran Yahav,Abstract semantic differencing via speculative correlation.
• Aaron Turon,Viktor Vafeiadis,Derek Dreyer,GPS: navigating weak memory with ghosts, protocols, and separation.
• Rifat Shahriyar,Stephen M. Blackburn,Kathryn S. McKinley,Fast conservative garbage collection.
• Wei Zhang,Per Larsen,Stefan Brunthaler,Michael Franz,Accelerating iterators in optimizing AST interpreters.
• John Altidor,Yannis Smaragdakis,Refactoring Java generics by inferring wildcards, in practice.
• Eric Holk,Ryan Newton,Jeremy G. Siek,Andrew Lumsdaine,Region-based memory management for GPU programming languages: enabling rich data structures on a spartan host.

2013

• Jisheng Zhao,Roberto Lublinerman,Zoran Budimlic,Swarat Chaudhuri,Vivek Sarkar,Isolation for nested task parallelism.
• Prodromos Gerakios,Aggelos Biboudis,Yannis Smaragdakis,Forsaking inheritance: supercharged delegation in DelphJ.
• Guoqing (Harry) Xu,Resurrector: a tunable object lifetime profiling technique for optimizing real-world programs.
• Aman Kansal,T. Scott Saponas,A. J. Bernheim Brush,Kathryn S. McKinley,Todd Mytkowicz,Ryder Ziola,The latency, accuracy, and battery (LAB) abstraction: programmer productivity and energy efficiency for continuous mobile context sensing.
• Veselin Raychev,Max Schäfer,Manu Sridharan,Martin T. Vechev,Refactoring with synthesis.
• Nick Mitchell,Peter F. Sweeney,On-the-fly capacity planning.
• Yannis Smaragdakis,George Balatsouras,George Kastrinis,Set-based pre-processing for points-to analysis.
• Stephan Herhut,Richard L. Hudson,Tatiana Shpeisman,Jaswanth Sreeram,River trail: a path to parallelism in JavaScript.
• Christos Dimoulas,Robert Bruce Findler,Matthias Felleisen,Option contracts.
• Tom Bergan,Luis Ceze,Dan Grossman,Input-covering schedules for multithreaded programs.
• Leo A. Meyerovich,Ariel S. Rabkin,Empirical analysis of programming language adoption.
• Joe Gibbs Politz,Alejandro Martinez,Matthew Milano,Sumner Warren,Daniel Patterson,Junsong Li,Anand Chitipothu,Shriram Krishnamurthi,Python: the full monty.
• Omer Tripp,Eric Koskinen,Mooly Sagiv,Turning nondeterminism into parallelism.
• Kristof Du Bois,Jennifer B. Sartor,Stijn Eyerman,Lieven Eeckhout,Bottle graphs: visualizing scalability bottlenecks in multi-threaded applications.
• Nathan Chong,Alastair F. Donaldson,Paul H. J. Kelly,Jeroen Ketema,Shaz Qadeer,Barrier invariants: a shared state abstraction for the analysis of data-dependent GPU kernels.
• Brian Norris,Brian Demsky,CDSchecker: checking concurrent data structures written with C/C++ atomics.
• Veselin Raychev,Martin T. Vechev,Manu Sridharan,Effective race detection for event-driven programs.
• Sai Deep Tetali,Mohsen Lesani,Rupak Majumdar,Todd D. Millstein,MrCrypt: static analysis for secure cloud computations.
• Katherine E. Coons,Madan Musuvathi,Kathryn S. McKinley,Bounded partial-order reduction.
• Christian DeLozier,Richard A. Eisenberg,Santosh Nagarakatte,Peter-Michael Osera,Milo M. K. Martin,Steve Zdancewic,Ironclad C++: a library-augmented type-safe subset of c++.
• Wontae Choi,George C. Necula,Koushik Sen,Guided GUI testing of android apps with minimal restart and approximate learning.
• Lingming Zhang,Lu Zhang,Sarfraz Khurshid,Injecting mechanical faults to localize developer faults for evolving software.
• Jipeng Huang,Michael D. Bond,Efficient context sensitivity for dynamic analyses via calling context uptrees and customized memory management.
• Tanzirul Azim,Iulian Neamtiu,Targeted and depth-first exploration for systematic testing of android apps.
• Vlad Ureche,Cristian Talau,Martin Odersky,Miniboxing: improving the speed to code size tradeoff in parametric polymorphism translations.
• Michael Carbin,Sasa Misailovic,Martin C. Rinard,Verifying quantitative reliability for programs that execute on unreliable hardware.
• Sean Treichler,Michael Bauer,Alex Aiken,Language support for dynamic, hierarchical data partitioning.
• Suparna Bhattacharya,Kanchi Gopinath,Mangala Gowri Nanda,Combining concern input with program analysis for bloat detection.
• Robin Salkeld,Gregor Kiczales,Interacting with dead objects.
• Rahul Sharma,Eric Schkufza,Berkeley R. Churchill,Alex Aiken,Data-driven equivalence checking.
• Daniele Cono D'Elia,Camil Demetrescu,Ball-Larus path profiling across multiple loop iterations.
• Sylvan Clebsch,Sophia Drossopoulou,Fully concurrent garbage collection of actors on many-core machines.
• Rifat Shahriyar,Stephen M. Blackburn,Xi Yang,Kathryn S. McKinley,Taking off the gloves with reference counting Immix.
• George Balatsouras,Yannis Smaragdakis,Class hierarchy complementation: soundly completing a partial type graph.
• You Li,Zhendong Su,Linzhang Wang,Xuandong Li,Steering symbolic execution to less traveled paths.
• Heather Miller,Philipp Haller,Eugene Burmako,Martin Odersky,Instant pickles: generating object-oriented pickler combinators for fast and extensible serialization.
• Michael D. Bond,Milind Kulkarni,Man Cao,Minjia Zhang,Meisam Fathi Salmi,Swarnendu Biswas,Aritra Sengupta,Jipeng Huang,OCTET: capturing and controlling cross-thread dependences efficiently.
• Etienne Kneuss,Ivan Kuraj,Viktor Kuncak,Philippe Suter,Synthesis modulo recursive functions.
• Isil Dillig,Thomas Dillig,Boyang Li,Kenneth L. McMillan,Inductive invariant generation via abductive inference.
• Hao Zhong,Zhendong Su,Detecting API documentation errors.
• Albert Noll,Thomas R. Gross,Online feedback-directed optimizations for parallel Java code.
• Gregor Richards,Christian Hammer,Francesco Zappa Nardelli,Suresh Jagannathan,Jan Vitek,Flexible access control for javascript.
• Yao Shi,Bernard Blackham,Gernot Heiser,Code optimizations using formally verified properties.
• Asger Feldthaus,Anders Møller,Semi-automatic rename refactoring for JavaScript.
• Dongdong Deng,Wei Zhang,Shan Lu,Efficient concurrency-bug detection across inputs.
• Tao Bao,Xiangyu Zhang,On-the-fly detection of instability problems in floating-point program execution.
• Carl Friedrich Bolz,Lukas Diekmann,Laurence Tratt,Storage strategies for collections in dynamically typed languages.
• Kaushik Ravichandran,Santosh Pande,Multiverse: efficiently supporting distributed high-level speculation.
• Michael Hoppe,Stefan Hanenberg,Do developers benefit from generic types?: an empirical comparison of generic and raw types in java.
• Viktor Vafeiadis,Chinmay Narayan,Relaxed separation logic: a program logic for C11 concurrency.

2012

• Daniel W. Barowy,Charlie Curtsinger,Emery D. Berger,Andrew McGregor,AutoMan: a platform for integrating human-based and digital computation.
• Kivanç Muslu,Yuriy Brun,Reid Holmes,Michael D. Ernst,David Notkin,Speculative analysis of integrated development environment recommendations.
• Alon Mishne,Sharon Shoham,Eran Yahav,Typestate-based semantic code search over partial programs.
• Haiping Zhao,Iain Proctor,Minghui Yang,Xin Qi,Mark Williams,Qi Gao,Guilherme Ottoni,Andrew Paroski,Scott MacVicar,Jason Evans,Stephen Tu,The HipHop compiler for PHP.
• K. Rustan M. Leino,Aleksandar Milicevic,Program extrapolation with jennisys.
• Kohei Suenaga,Ryota Fukuda,Atsushi Igarashi,Type-based safe resource deallocation for shared-memory concurrency.
• Ying Zhang,Gang Huang,Xuanzhe Liu,Wei Zhang,Hong Mei,Shunxiang Yang,Refactoring android Java code for on-demand computation offloading.
• Christopher M. Hayden,Edward K. Smith,Michail Denchev,Michael Hicks,Jeffrey S. Foster,Kitsune: efficient, general-purpose dynamic software updating for C.
• Francesco Logozzo,Thomas Ball,Modular and verified automatic program repair.
• Subhajit Datta,Renuka Sindhgatta,Bikram Sengupta,Talk versus work: characteristics of developer collaboration on the jazz platform.
• T. Stephen Strickland,Sam Tobin-Hochstadt,Robert Bruce Findler,Matthew Flatt,Chaperones and impersonators: run-time support for reasonable interposition.
• Zhongxian Gu,Earl T. Barr,Drew Schleck,Zhendong Su,Reusing debugging knowledge via trace-based bug search.
• Sameer Kulkarni,John Cavazos,Mitigating the compiler optimization phase-ordering problem using machine learning.
• Laura Effinger-Dean,Brandon Lucia,Luis Ceze,Dan Grossman,Hans-Juergen Boehm,IFRit: interference-free regions for dynamic data-race detection.
• Youngjoon Jo,Milind Kulkarni,Automatically enhancing locality for tree traversals with traversal splicing.
• Sam Tobin-Hochstadt,David Van Horn,Higher-order symbolic execution via contracts.
• Tomas Kalibera,Matthew Mole,Richard E. Jones,Jan Vitek,A black-box approach to understanding concurrency in DaCapo.
• Grigore Rosu,Andrei Stefanescu,Checking reachability using matching logic.
• Adam Betts,Nathan Chong,Alastair F. Donaldson,Shaz Qadeer,Paul Thomson,GPUVerify: a verifier for GPU kernels.
• Yuriy Solodkyy,Gabriel Dos Reis,Bjarne Stroustrup,Open and efficient type switch for C++.
• Sébastien Bocq,Koen Daenen,Molecule: using monadic and streaming I/O to compose process networks on the JVM.
• Michael Cohen,Haitao Steve Zhu,Emgin Ezgi Senem,Yu David Liu,Energy types.
• Jie Yu,Satish Narayanasamy,Cristiano Pereira,Gilles Pokam,Maple: a coverage-driven testing tool for multithreaded programs.
• Vivek Kumar,Daniel Frampton,Stephen M. Blackburn,David Grove,Olivier Tardieu,Work-stealing without the baggage.
• Zachary R. Anderson,Efficiently combining parallel software using fine-grained, language-level, hierarchical resource management policies.
• Dimitrios Prountzos,Roman Manevich,Keshav Pingali,Elixir: a system for synthesizing concurrent graph programs.
• Tao Bao,Yunhui Zheng,Xiangyu Zhang,White box sampling in uncertain data processing enabled by program analysis.
• Juan M. Tamayo,Alex Aiken,Nathan Grasso Bronson,Mooly Sagiv,Understanding the behavior of database operations under program control.
• Wei Huang,Ana Milanova,Werner Dietl,Michael D. Ernst,Reim & ReImInfer: checking and inference of reference immutability and method purity.
• Jeff Huang,Charles Zhang,LEAN: simplifying concurrency bug reproduction via replay-supported execution reduction.
• Anton Willy Dubrau,Laurie J. Hendren,Taming MATLAB.
• Olivier Tardieu,Nathaniel Nystrom,Igor Peshansky,Vijay A. Saraswat,Constrained kinds.
• Stephen Magill,Michael Hicks,Suriya Subramanian,Kathryn S. McKinley,Automating object transformations for dynamic software updating.
• Seonghoon Kang,Sukyoung Ryu,Formal specification of a JavaScript module system.
• Yanhong A. Liu,Scott D. Stoller,Bo Lin,Michael Gorbovitski,From clarity to efficiency for distributed algorithms.
• Vincent St-Amour,Sam Tobin-Hochstadt,Matthias Felleisen,Optimization coaching: optimizers learn to communicate with programmers.
• Colin S. Gordon,Matthew J. Parkinson,Jared Parsons,Aleks Bromfield,Joe Duffy,Uniqueness and reference immutability for safe parallelism.
• Ravi Chugh,David Herman,Ranjit Jhala,Dependent types for JavaScript.
• Stefan Muller,Stephen Chong,Towards a practical secure concurrent language.
• Jeff Huang,Charles Zhang,Execution privatization for scheduler-oblivious concurrent programs.
• Charles Lucas,Sebastian G. Elbaum,David S. Rosenblum,Detecting problematic message sequences and frequencies in distributed systems.
• Michael Kling,Sasa Misailovic,Michael Carbin,Martin C. Rinard,Bolt: on-demand infinite loop escape in unmodified binaries.
• Hiroshi Inoue,Hiroshige Hayashizaki,Peng Wu,Toshio Nakatani,Adaptive multi-level compilation in a trace-based Java JIT compiler.
• José G. Castaños,David Edelsohn,Kazuaki Ishizaki,Priya Nagpurkar,Toshio Nakatani,Takeshi Ogasawara,Peng Wu,On the benefits and pitfalls of extending a statically typed language JIT compiler for dynamic scripting languages.
• Shams Mahmood Imam,Vivek Sarkar,Integrating task parallelism with actors.
• Giorgio Ausiello,Camil Demetrescu,Irene Finocchi,Donatella Firmani,k-Calling context profiling.
• Asumu Takikawa,T. Stephen Strickland,Christos Dimoulas,Sam Tobin-Hochstadt,Matthias Felleisen,Gradual typing for first-class classes.
• Pavel Parizek,Ondrej Lhoták,Predicate abstraction of Java programs with collections.
• Bo Wu,Zhijia Zhao,Xipeng Shen,Yunlian Jiang,Yaoqing Gao,Raúl Silvera,Exploiting inter-sequence correlations for program behavior prediction.
• Christian Kästner,Klaus Ostermann,Sebastian Erdweg,A variability-aware module system.
• Patrick Cousot,Radhia Cousot,Francesco Logozzo,Michael Barnett,An abstract interpretation framework for refactoring with application to extract methods with contracts.
• Clemens Mayer,Stefan Hanenberg,Romain Robbes,Éric Tanter,Andreas Stefik,An empirical study of the influence of static type systems on the usability of undocumented software.
• Hung-Wei Tseng,Dean M. Tullsen,Software data-triggered threads.
• Junaid Haroon Siddiqui,Sarfraz Khurshid,Scaling symbolic execution using ranged analysis.
• Jaswanth Sreeram,Santosh Pande,Safe compiler-driven transaction checkpointing and recovery.
• Todd W. Schiller,Michael D. Ernst,Reducing the barriers to writing verified specifications.
• Guoqing (Harry) Xu,Finding reusable data structures.
• Fadi Meawad,Gregor Richards,Floréal Morandat,Jan Vitek,Eval begone!: semi-automated removal of eval from javascript programs.
• Jennifer B. Sartor,Lieven Eeckhout,Exploring multi-threaded Java application performance on multicore hardware.

2011

• Lennart C. L. Kats,Rob Vermaas,Eelco Visser,Integrated language definition testing: enabling test-driven language development.
• Hyeonseung Im,Keiko Nakata,Jacques Garrigue,Sungwoo Park,A syntactic type system for recursive modules.
• Suresh Thummalapenta,Tao Xie,Nikolai Tillmann,Jonathan de Halleux,Zhendong Su,Synthesizing method sequences for high-coverage testing.
• Romain Cledat,Tushar Kumar,Santosh Pande,Efficiently speeding up sequential computation through the n-way programming model.
• Hari K. Pyla,Calvin J. Ribbens,Srinidhi Varadarajan,Exploiting coarse-grain speculative parallelism.
• Sebastian Erdweg,Tillmann Rendel,Christian Kästner,Klaus Ostermann,SugarJ: library-based syntactic language extensibility.
• Pallavi Joshi,Haryadi S. Gunawi,Koushik Sen,PREFAIL: a programmable tool for multiple-failure injection.
• Jesse Doherty,Laurie J. Hendren,Soroush Radpour,Kind analysis for MATLAB.
• Joshua Sunshine,Karl Naden,Sven Stork,Jonathan Aldrich,Éric Tanter,First-class state change in plaid.
• Benjamin Delaware,William R. Cook,Don S. Batory,Product lines of theorems.
• Pedro da Rocha Pinto,Thomas Dinsdale-Young,Mike Dodds,Philippa Gardner,Mark J. Wheelhouse,A simple abstraction for complex concurrent indexes.
• Aaron Joseph Turon,Claudio V. Russo,Scalable join patterns.
• Milan Jovic,Andrea Adamoli,Matthias Hauswirth,Catch me if you can: performance bug detection in the wild.
• Sooel Son,Kathryn S. McKinley,Vitaly Shmatikov,RoleCast: finding missing security checks when you do not know what checks are.
• Donghwan Jeon,Saturnino Garcia,Christopher M. Louie,Michael Bedford Taylor,Kismet: parallel speedup estimates for serial programs.
• Amin Shali,William R. Cook,Hybrid partial evaluation.
• Cristina David,Wei-Ngan Chin,Immutable specifications for more concise and precise verification.
• Thomas Würthinger,Danilo Ansaloni,Walter Binder,Christian Wimmer,Hanspeter Mössenböck,Safe and atomic run-time code evolution for Java and its application to dynamic AOP.
• Eric E. Allen,Justin Hilburn,Scott Kilpatrick,Victor Luchangco,Sukyoung Ryu,David Chase,Guy L. Steele Jr.,Type checking modular multiple dispatch with parametric polymorphism and multiple inheritance.
• David H. Lorenz,Boaz Rosenan,Cedalion: a language for language oriented programming.
• Sebastian Burckhardt,Daan Leijen,Caitlin Sadowski,Jaeheon Yi,Thomas Ball,Two for the price of one: a model for parallel and incremental computation.
• Christian Kästner,Paolo G. Giarrusso,Tillmann Rendel,Sebastian Erdweg,Klaus Ostermann,Thorsten Berger,Variability-aware parsing in the presence of lexical macros and conditional compilation.
• Zef Hemel,Eelco Visser,Declaratively programming the mobile web with Mobl.
• Ohad Shacham,Nathan Grasso Bronson,Alex Aiken,Mooly Sagiv,Martin T. Vechev,Eran Yahav,Testing atomicity of composed concurrent operations.
• Manu Sridharan,Shay Artzi,Marco Pistoia,Salvatore Guarnieri,Omer Tripp,Ryan Berg,F4F: taint analysis of framework-based web applications.
• Umut A. Acar,Arthur Charguéraud,Mike Rainey,Oracle scheduling: controlling granularity in implicitly parallel languages.
• Eva Darulova,Viktor Kuncak,Trustworthy numerical computation in Scala.
• Prasad A. Kulkarni,JIT compilation policy for modern machines.
• Thomas H. Austin,Tim Disney,Cormac Flanagan,Virtual values for language extension.
• Asger Feldthaus,Todd D. Millstein,Anders Møller,Max Schäfer,Frank Tip,Tool-supported refactoring for JavaScript.
• Siliang Li,Gang Tan,JET: exception checking in the Java native interface.
• Dasarath Weeratunge,Xiangyu Zhang,Suresh Jagannathan,Accentuating the positive: atomicity inference and enforcement using correct executions.
• Edward Aftandilian,Samuel Z. Guyer,Martin T. Vechev,Eran Yahav,Asynchronous assertions.
• Chuanle Ke,Lei Liu,Chao Zhang,Tongxin Bai,Bryan Jacobs,Chen Ding,Safe parallel programming using dynamic dependence hints.
• Roberto Lublinerman,Jisheng Zhao,Zoran Budimlic,Swarat Chaudhuri,Vivek Sarkar,Delegated isolation.
• Youngjoon Jo,Milind Kulkarni,Enhancing locality for recursive traversals of recursive structures.
• Raymond P. L. Buse,Caitlin Sadowski,Westley Weimer,Benefits and barriers of user evaluation in software engineering research.
• Tongping Liu,Emery D. Berger,SHERIFF: precise detection and automatic mitigation of false sharing.
• Guy Golan-Gueta,Nathan Grasso Bronson,Alex Aiken,G. Ramalingam,Mooly Sagiv,Eran Yahav,Automatic fine-grain locking using shape properties.
• Zachary R. Anderson,David Gay,Composable, nestable, pessimistic atomic statements.
• Michael D. Adams,Andrew W. Keep,Jan Midtgaard,Matthew Might,Arun Chauhan,R. Kent Dybvig,Flow-sensitive type recovery in linear-log time.
• Xi Yang,Stephen M. Blackburn,Daniel Frampton,Jennifer B. Sartor,Kathryn S. McKinley,Why nothing matters: the impact of zeroing.
• Tim Harris,Martín Abadi,Rebecca Isaacs,Ross McIlroy,AC: composable asynchronous IO for native languages.
• Jesse A. Tov,Riccardo Pucella,A theory of substructural types and control.
• Lintaro Ina,Atsushi Igarashi,Gradual typing for generics.
• Arun Raman,Greta Yorsh,Martin T. Vechev,Eran Yahav,Sprint: speculative prefetching of remote data.
• Gregor Richards,Andreas Gal,Brendan Eich,Jan Vitek,Automated construction of JavaScript benchmarks.
• Camil Demetrescu,Irene Finocchi,Andrea Ribichini,Reactive imperative programming with dataflow constraints.
• Andreas Sewe,Mira Mezini,Aibek Sarimbekov,Walter Binder,Da capo con scala: design and analysis of a scala benchmark suite for the java virtual machine.
• Kevin J. Hoffman,Harrison Metzger,Patrick Eugster,Ribbons: a partially shared memory programming model.
• Toon Verwaest,Camillo Bruni,Mircea Lungu,Oscar Nierstrasz,Flexible object layouts: enabling lightweight language extensions by intercepting slot access.
• Du Li,Witawas Srisa-an,Matthew B. Dwyer,SOS: saving time in dynamic race detection with stationary analysis.
• Alexander J. Summers,Peter Müller,Freedom before commitment: a lightweight type system for object initialisation.
• Matthew A. Hammer,Georg Neis,Yan Chen,Umut A. Acar,Self-adjusting stack machines.
• Yewen Pu,Rastislav Bodík,Saurabh Srivastava,Synthesis of first-order dynamic programming algorithms.
• Ravichandhran Madhavan,Raghavan Komondoor,Null dereference verification via over-approximated weakest pre-conditions analysis.
• Kai Tian,Eddy Z. Zhang,Xipeng Shen,A step towards transparent integration of input-consciousness into dynamic program optimizations.
• Omer Tripp,Greta Yorsh,John Field,Mooly Sagiv,HAWKEYE: effective discovery of dataflow impediments to parallelization.
• Peng Wu,Hiroshige Hayashizaki,Hiroshi Inoue,Toshio Nakatani,Reducing trace selection footprint for large-scale Java applications without performance loss.
• Kuat Yessenov,Zhilei Xu,Armando Solar-Lezama,Data-driven synthesis for object-oriented frameworks.
• Zachary Palmer,Scott F. Smith,Backstage Java: making a difference in metaprogramming.

2010

• Max Schäfer,Oege de Moor,Specifying and implementing refactorings.
• Christoph Reichenbach,Neil Immerman,Yannis Smaragdakis,Edward Aftandilian,Samuel Z. Guyer,What can the GC compute efficiently?: a language for heap assertions at GC time.
• Shigeru Chiba,Atsushi Igarashi,Salikh Zakirov,Mostly modular compilation of crosscutting concerns by contextual predicate dispatch.
• Wei Li,Charles Zhang,Songlin Hu,G-Finder: routing programming questions closer to the experts.
• Charlotte Herzeel,Pascal Costanza,Dynamic parallelization of recursive code: part 1: managing control flow interactions with the continuator.
• Tudor Dumitras,Priya Narasimhan,Eli Tilevich,To upgrade or not to upgrade: impact of online upgrades across multiple administrative domains.
• Marco Servetto,Elena Zucca,MetaFJig: a meta-circular composition language for Java-like classes.
• Nicholas R. Cameron,James Noble,Tobias Wrigstad,Tribal ownership.
• Shachar Itzhaky,Sumit Gulwani,Neil Immerman,Mooly Sagiv,A simple inductive synthesis methodology and its applications.
• Stefan Hanenberg,An experiment about static and dynamic type systems: doubts about the positive impact of static type systems on development time.
• Michael Roberson,Chandrasekhar Boyapati,Efficient modular glass box software model checking.
• Yoav Zibin,Alex Potanin,Paley Li,Mahmood Ali,Michael D. Ernst,Ownership and immutability in generic Java.
• Kenneth C. Arnold,Henry Lieberman,Managing ambiguity in programming by finding unambiguous examples.
• Jay A. McCarthy,The two-state solution: native and serializable continuations accord.
• Benjamin P. Wood,Adrian Sampson,Luis Ceze,Dan Grossman,Composable specifications for structured shared-memory communication.
• Guoliang Jin,Aditya V. Thakur,Ben Liblit,Shan Lu,Instrumentation and sampling strategies for cooperative concurrency bug isolation.
• Isil Dillig,Thomas Dillig,Alex Aiken,Symbolic heap abstraction with demand-driven axiomatization of memory invariants.
• Percy Liang,Omer Tripp,Mayur Naik,Mooly Sagiv,A dynamic evaluation of the precision of static heap abstractions.
• Aditya Kulkarni,Yu David Liu,Scott F. Smith,Task types for pervasive atomicity.
• Jenny Quillien,Dave West,Rubber ducks, nightmares, and unsaturated predicates: proto-scientific schemata are good for agile.
• Stefan Hanenberg,Faith, hope, and love: an essay on software science's neglect of human factors.
• Michal Wegiel,Chandra Krintz,Cross-language, type-safe, and transparent object sharing for co-located managed runtimes.
• Lennart C. L. Kats,Eelco Visser,Guido Wachsmuth,Pure and declarative syntax definition: paradise lost and regained.
• Erik R. Altman,Matthew Arnold,Stephen Fink,Nick Mitchell,Performance analysis of idle programs.
• Joshua S. Auerbach,David F. Bacon,Perry Cheng,Rodric M. Rabbah,Lime: a Java-compatible and synthesizable language for heterogeneous architectures.
• Mario Méndez-Lojo,Augustine Mathew,Keshav Pingali,Parallel inclusion-based points-to analysis.
• Kazunori Ogata,Dai Mikurube,Kiyokuni Kawachiya,Scott Trent,Tamiya Onodera,A study of Java's non-Java memory.
• Michael Bebenita,Florian Brandner,Manuel Fähndrich,Francesco Logozzo,Wolfram Schulte,Nikolai Tillmann,Herman Venter,SPUR: a trace-based JIT compiler for CIL.
• Andrew Sorensen,Henry J. Gardner,Programming with time: cyber-physical programming with impromptu.
• Rashina Hoda,Philippe Kruchten,James Noble,Stuart Marshall,Agility in context.
• Stephan van Staden,Cristiano Calcagno,Reasoning about multiple related abstractions with MultiStar.
• Hoan Anh Nguyen,Tung Thanh Nguyen,Gary Wilson Jr.,Anh Tuan Nguyen,Miryung Kim,Tien N. Nguyen,A graph-based approach to API usage adaptation.
• Sebastian Burckhardt,Alexandro Baldassin,Daan Leijen,Concurrent programming with revisions and isolation types.
• Stephen Kou,Jens Palsberg,From OO to FPGA: fitting round objects into square hardware?
• Stephen Kell,Component adaptation and assembly using interface relations.
• Paul Adamczyk,Munawar Hafiz,The Tower of Babel did not fail.
• Hridesh Rajan,Steven M. Kautz,Wayne Rowcliffe,Concurrency by modularity: design patterns, a case in point.
• Xin Qi,Andrew C. Myers,Homogeneous family sharing.
• Karl Klose,Klaus Ostermann,Modular logic metaprogramming.
• Yao Shi,Soyeon Park,Zuoning Yin,Shan Lu,Yuanyuan Zhou,Wenguang Chen,Weimin Zheng,Do I use the wrong definition?: DeFuse: definition-use invariants for detecting concurrency and sequential bugs.
• Bruno C. d. S. Oliveira,Adriaan Moors,Martin Odersky,Type classes as objects and implicits.
• Mark Gabel,Junfeng Yang,Yuan Yu,Moisés Goldszmidt,Zhendong Su,Scalable and systematic detection of buggy inconsistencies in source code.
• Gautam Upadhyaya,Samuel P. Midkiff,Vijay S. Pai,Automatic atomic region identification in shared memory SPMD programs.
• Martin C. Rinard,Henry Hoffmann,Sasa Misailovic,Stelios Sidiroglou,Patterns and statistical analysis for understanding reduced resource computing.
• Harold Ossher,Rachel K. E. Bellamy,Ian Simmonds,David Amid,Ateret Anaby-Tavor,Matthew Callery,Michael Desmond,Jacqueline de Vries,Amit Fisher,Sophia Krasikov,Flexible modeling tools for pre-requirements analysis: conceptual architecture and research challenges.
• Kai Tian,Yunlian Jiang,Eddy Z. Zhang,Xipeng Shen,An input-centric paradigm for program dynamic optimizations.
• Ross McIlroy,Joe Sventek,Hera-JVM: a runtime system for heterogeneous multi-core architectures.
• James Swaine,Kevin Tew,Peter A. Dinda,Robert Bruce Findler,Matthew Flatt,Back to the futures: incremental parallelization of existing sequential runtime systems.
• Puneet Kapur,Bradley Cossette,Robert J. Walker,Refactoring references for library migration.
• Hassan Chafi,Zach DeVito,Adriaan Moors,Tiark Rompf,Arvind K. Sujeeth,Pat Hanrahan,Martin Odersky,Kunle Olukotun,Language virtualization for heterogeneous parallel computing.
• Nicholas D. Matsakis,Thomas R. Gross,A time-aware type system for data-race protection and guaranteed initialization.
• Richard P. Gabriel,Kevin J. Sullivan,Better science through art.
• Toon Verwaest,Camillo Bruni,David Gurtner,Adrian Lienhard,Oscar Nierstrasz,Pinocchio: bringing reflection to life with first-class interpreters.
• Samuel Davis,Gregor Kiczales,Registration-based language abstractions.
• Julien Mercadal,Quentin Enard,Charles Consel,Nicolas Loriant,A domain-specific approach to architecturing error handling in pervasive computing.
• Casey Klein,Matthew Flatt,Robert Bruce Findler,Random testing for higher-order, stateful programs.
• Lennart C. L. Kats,Eelco Visser,The spoofax language workbench: rules for declarative specification of languages and IDEs.
• Rahul Purandare,Matthew B. Dwyer,Sebastian G. Elbaum,Monitor optimization via stutter-equivalent loop transformation.
• Benjamin S. Lerner,Herman Venter,Dan Grossman,Supporting dynamic, third-party code customizations in JavaScript using aspects.

2009

• Jungwoo Ha,Matthew Arnold,Stephen M. Blackburn,Kathryn S. McKinley,A concurrent dynamic analysis framework for multicore hardware.
• Hiroshi Inoue,Toshio Nakatani,How a Java VM can get more from a hardware performance monitor.
• Roman Knöll,Mira Mezini,pi: a pattern language.
• Thomas Mullen,Writing code for other people: cognitive psychology and the fundamentals of good software design principles.
• Lennart C. L. Kats,Maartje de Jonge,Emma Nilsson-Nyman,Eelco Visser,Providing rapid feedback in generated modular language environments: adding error recovery to scannerless generalized-LR parsing.
• Leo A. Meyerovich,Arjun Guha,Jacob P. Baskin,Gregory H. Cooper,Michael Greenberg,Aleks Bromfield,Shriram Krishnamurthi,Flapjax: a programming language for Ajax applications.
• Chieri Saito,Atsushi Igarashi,Self type constructors.
• Mangala Gowri Nanda,Senthil Mani,Vibha Singhal Sinha,Saurabh Sinha,Demystifying model transformations: an approach based on automated rule inference.
• Daan Leijen,Wolfram Schulte,Sebastian Burckhardt,The design of a task parallel library.
• Roberto Lublinerman,Swarat Chaudhuri,Pavol Cerný,Parallel programming with object assemblies.
• Roland Ducournau,Floréal Morandat,Jean Privat,Empirical assessment of object-oriented implementations with multiple inheritance and static typing.
• Elisa L. A. Baniassad,Clayton G. Myers,An exploration of program as language.
• Dan Tsafrir,Robert W. Wisniewski,David F. Bacon,Bjarne Stroustrup,Minimizing dependencies within generic classes for faster and smaller programs.
• Dirk Riehle,Design pattern density defined.
• Takeshi Ogasawara,NUMA-aware memory manager with dominant-thread-based copying GC.
• Jenny Quillien,Pam Rostal,Dave West,Agile anthropology and Alexander's architecture: an essay in three voices.
• Daniel von Dincklage,Amer Diwan,Optimizing programs with intended semantics.
• Byeongcheol Lee,Martin Hirzel,Robert Grimm,Kathryn S. McKinley,Debug all your code: portable mixed-environment debugging.
• Marwan Abi-Antoun,Jonathan Aldrich,Static extraction and conformance analysis of hierarchical runtime architectural structure using annotations.
• Robert L. Bocchino Jr.,Vikram S. Adve,Danny Dig,Sarita V. Adve,Stephen Heumann,Rakesh Komuravelli,Jeffrey Overbey,Patrick Simmons,Hyojin Sung,Mohsen Vakilian,A type and effect system for deterministic parallel Java.
• William R. Cook,On understanding data abstraction, revisited.
• Martin Bravenboer,Yannis Smaragdakis,Strictly declarative specification of sophisticated points-to analyses.
• Emery D. Berger,Ting Yang,Tongping Liu,Gene Novark,Grace: safe multithreaded programming for C/C++.
• Bard Bloom,John Field,Nathaniel Nystrom,Johan Östlund,Gregor Richards,Rok Strnisa,Jan Vitek,Tobias Wrigstad,Thorn: robust, concurrent, extensible scripting on the JVM.
• Donna Malayeri,Jonathan Aldrich,CZ: multiple inheritance without diamonds.
• Michael Furr,Jong-hoon (David) An,Jeffrey S. Foster,Profile-guided static typing for dynamic scripting languages.
• Todd Mytkowicz,Devin Coughlin,Amer Diwan,Inferred call path profiling.
• Jeffrey L. Overbey,Ralph E. Johnson,Regrowing a language: refactoring tools allow programming languages to evolve.
• Yi Zhao,Jin Shi,Kai Zheng,Haichuan Wang,Haibo Lin,Ling Shao,Allocation wall: a limiting factor of Java applications on emerging multi-core platforms.
• Mark Mahoney,Software evolution and the moving picture metaphor.
• Philippe Charles,Robert M. Fuhrer,Stanley M. Sutton Jr.,Evelyn Duesterwald,Jurgen J. Vinju,Accelerating the creation of customized, language-Specific IDEs in Eclipse.
• Myoungkyu Song,Eli Tilevich,Enhancing source-level programming tools with an awareness of transparent program transformations.
• Frédéric Pluquet,Stefan Langerman,Roel Wuyts,Executing code in the past: efficient in-memory object graph versioning.

2008

• Zachary Tatlock,Chris Tucker,David Shuffelton,Ranjit Jhala,Sorin Lerner,Deep typechecking and refactoring.
• Daniel Smith,Robert Cartwright,Java type inference is broken: can we fix it?
• Claudio V. Russo,Join patterns for visual basic.
• Matthew Arnold,Martin T. Vechev,Eran Yahav,QVM: an efficient runtime for detecting defects in deployed systems.
• Gregory B. Prokopski,Clark Verbrugge,Analyzing the performance of code-copying virtual machines.
• Barthélémy Dagenais,Laurie J. Hendren,Enabling static analysis for partial java programs.
• Michael D. Bond,Kathryn S. McKinley,Tolerating memory leaks.
• Kiyokuni Kawachiya,Kazunori Ogata,Tamiya Onodera,Analysis and reduction of memory inefficiencies in Java strings.
• Richard P. Gabriel,Designed as designer.
• Dino Distefano,Matthew J. Parkinson,jStar: towards practical verification for java.
• Darren Willis,David J. Pearce,James Noble,Caching and incrementalisation in the java query language.
• Nomair A. Naeem,Ondrej Lhoták,Typestate-like analysis of multiple interacting objects.
• Nathaniel Nystrom,Vijay A. Saraswat,Jens Palsberg,Christian Grothoff,Constrained types for object-oriented languages.
• Nels E. Beckman,Kevin Bierhoff,Jonathan Aldrich,Verifying correct usage of atomic blocks and typestate.
• Max Schäfer,Torbjörn Ekman,Oege de Moor,Sound and extensible renaming for java.
• Ajeet Shankar,Matthew Arnold,Rastislav Bodík,Jolt: lightweight dynamic analysis and removal of object churn.
• Michael Roberson,Melanie Harries,Paul T. Darga,Chandrasekhar Boyapati,Efficient software model checking of soundness of type systems.
• Radu Muschevici,Alex Potanin,Ewan D. Tempero,James Noble,Multiple dispatch in practice.
• Pietro Ferrara,Francesco Logozzo,Manuel Fähndrich,Safer unsafe code for .NET.
• Hans Schippers,Dirk Janssens,Michael Haupt,Robert Hirschfeld,Delegation-based semantics for modularizing crosscutting concerns.
• Rick Chern,Kris De Volder,The impact of static-dynamic coupling on remodularization.
• Ben Bellamy,Pavel Avgustinov,Oege de Moor,Damien Sereni,Efficient local type inference.
• Bruno C. d. S. Oliveira,Meng Wang,Jeremy Gibbons,The visitor pattern as a reusable, generic, type-safe component.
• Wesley Tansey,Eli Tilevich,Annotation refactoring: inferring upgrade transformations for legacy applications.
• Christopher Simpkins,Sooraj Bhat,Charles Lee Isbell Jr.,Michael Mateas,Towards adaptive programming: integrating reinforcement learning into a programming language.
• Lennart C. L. Kats,Martin Bravenboer,Eelco Visser,Mixing source and bytecode: a case for compilation by normalization.
• Andy Georges,Lieven Eeckhout,Dries Buytaert,Java performance evaluation through rigorous replay compilation.
• Florian T. Schneider,Vijay Menon,Tatiana Shpeisman,Ali-Reza Adl-Tabatabai,Dynamic optimization for efficient strong atomicity.
• Ben Wiedermann,Ali Ibrahim,William R. Cook,Interprocedural query extraction for transparent persistence.
• Madhu Gopinathan,Sriram K. Rajamani,Enforcing object protocols by combining static and runtime analysis.
• Adriaan Moors,Frank Piessens,Martin Odersky,Generics of a higher kind.
• Yang Ni,Adam Welc,Ali-Reza Adl-Tabatabai,Moshe Bach,Sion Berkowits,James Cownie,Robert Geva,Sergey Kozhukow,Ravi Narayanaswamy,Jeffrey Olivier,Serguei Preis,Bratin Saha,Ady Tal,Xinmin Tian,Design and implementation of transactional constructs for C/C++.
• Feng Xian,Witawas Srisa-an,Hong Jiang,Contention-aware scheduler: unlocking execution parallelism in multithreaded java programs.
• Pierre Baldi,Cristina Videira Lopes,Erik Linstead,Sushil Krishna Bajracharya,A theory of aspects as latent topics.
• Eric Bouillet,Mark Feblowitz,Zhen Liu,Anand Ranganathan,Anton Riabov,A tag-based approach for the design and composition of information processing applications.
• Joseph Gil,Itay Maman,Whiteoak: introducing structural typing into java.

2007

• Rok Strnisa,Peter Sewell,Matthew J. Parkinson,The java module system: core design and semantic definition.
• Torbjörn Ekman,Görel Hedin,The jastadd extensible java compiler.
• Sean McDirmid,Living it up with a live programming language.
• Vaidas Gasiunas,Mira Mezini,Klaus Ostermann,Dependent classes.
• Martin Hirzel,Robert Grimm,Jeannie: granting java native interface developers their wishes.
• Michael D. Bond,Nicholas Nethercote,Stephen W. Kent,Samuel Z. Guyer,Kathryn S. McKinley,Tracking bad apples: reporting the origin of null and undefined value errors.
• Peter Müller,Arsenii Rudich,Ownership transfer in universe types.
• Jesper Honig Spring,Jean Privat,Rachid Guerraoui,Jan Vitek,Streamflex: high-throughput stream programming in java.
• Nick Mitchell,Gary Sevitsky,The causes of bloat, the limits of health.
• David Greenfieldboyce,Jeffrey S. Foster,Type qualifier inference for java.
• Martin C. Rinard,Using early phase termination to eliminate load imbalances at barrier synchronization points.
• Yannis Smaragdakis,Anthony Kay,Reimer Behrends,Michal Young,Transactions with isolation and cooperation.
• Bassem Elkarablieh,Sarfraz Khurshid,Duy Vu,Kathryn S. McKinley,Starc: static analysis for efficient repair of complex data.
• Stéphane Ducasse,Roel Wuyts,Alexandre Bergel,Oscar Nierstrasz,User-changeable visibility: resolving unanticipated name clashes in traits.
• Manuel Fähndrich,Songtao Xia,Establishing object invariants with delayed types.
• Avraham Leff,James T. Rayfield,Webrb: evaluating a visual domain-specific language for building relational web-applications.
• Martin C. Rinard,Living in the comfort zone.
• Thomas Kühne,Daniel Schreiber,Can programming be liberated from the two-level style: multi-level programming with deepjava.
• Michael D. Bond,Kathryn S. McKinley,Probabilistic calling context.
• Jonathan Edwards,No ifs, ands, or buts: uncovering the simplicity of conditionals.
• Andy Georges,Dries Buytaert,Lieven Eeckhout,Statistically rigorous java performance evaluation.
• Kevin Bierhoff,Jonathan Aldrich,Modular typestate checking of aliased objects.
• James Sasitorn,Robert Cartwright,Component nextgen: a sound and expressive component framework for java.
• Atsushi Igarashi,Mirko Viroli,Variant path types for scalable extensibility.
• Uri Dekel,James D. Herbsleb,Notation and representation in collaborative object-oriented design: an observational study.
• Dan Grossman,The transactional memory / garbage collection analogy.
• Pavel Avgustinov,Julian Tibble,Oege de Moor,Making trace monitors feasible.
• Guillaume Pothier,Éric Tanter,José M. Piquer,Scalable omniscient debugging.
• Nicholas R. Cameron,Sophia Drossopoulou,James Noble,Matthew J. Smith,Multiple ownership.
• Steve M. Shaner,Gary T. Leavens,David A. Naumann,Modular verification of higher-order methods with mandatory calls specified by model programs.
• Gang Tan,Greg Morrisett,Ilea: inter-language analysis across java and c.
• Gavin M. Bierman,Erik Meijer,Mads Torgersen,Lost in translation: formalizing proposed extensions to c#.
• Feng Chen,Grigore Rosu,Mop: an efficient and generic runtime verification framework.
• Erik Meijer,Confessions of a used programming language salesman.
• Sebastian Fleissner,Elisa L. A. Baniassad,Epi-aspects: aspect-oriented conscientious software.
• Kin-Keung Ma,Jeffrey S. Foster,Inferring aliasing and encapsulation properties for java.
• Feng Xian,Witawas Srisa-an,Hong Jiang,Microphase: an approach to proactively invoking garbage collection for improved performance.
• Dries Buytaert,Andy Georges,Michael Hind,Matthew Arnold,Lieven Eeckhout,Koen De Bosschere,Using hpm-sampling to drive dynamic compilation.
• Sergei Kojarski,David H. Lorenz,Awesome: an aspect co-weaving system for composing multiple aspect-oriented extensions.

2006

• Richard P. Gabriel,Ron Goldman,Conscientious software.
• Lo Kwun Kit,Chan Kwun Man,Elisa L. A. Baniassad,Isolating and relating concerns in requirements using latent semantic analysis.
• Jim Waldo,On system design.
• Daniel Wasserrab,Tobias Nipkow,Gregor Snelting,Frank Tip,An operational semantics and type safety prooffor multiple inheritance in C++.
• Patrick Th. Eugster,Uniform proxies for Java.
• Gareth Baxter,Marcus R. Frean,James Noble,Mark Rickerby,Hayden Smith,Matt Visser,Hayden Melton,Ewan D. Tempero,Understanding the shape of Java software.
• Friedrich Steimann,The paradoxical success of aspect-oriented programming.
• Christoph Bockisch,Matthew Arnold,Tom Dinkelaker,Mira Mezini,Adapting virtual machine techniques for seamless aspect support.
• John Cavazos,Michael F. P. O'Boyle,Method-specific dynamic compilation using logistic regression.
• Ben Titzer,Virgil: objects on the head of a pin.
• Alessandro Warth,Milan Stanojevic,Todd D. Millstein,Statically scoped object adaptation with expanders.
• DeLesley Hutchins,Eliminating distinctions of class: using prototypes to model virtual classes.
• Martin Bravenboer,Éric Tanter,Eelco Visser,Declarative, formal, and extensible syntax definition for aspectJ.
• Christoph Bockisch,Sebastian Kanthak,Michael Haupt,Matthew Arnold,Mira Mezini,Efficient control flow quantification.
• Yu David Liu,Scott F. Smith,A formal framework for component deployment.
• Naiyana Sahavechaphan,Kajal T. Claypool,XSnippet: mining For sample code.
• Douglas Gregor,Jaakko Järvi,Jeremy G. Siek,Bjarne Stroustrup,Gabriel Dos Reis,Andrew Lumsdaine,Concepts: linguistic support for generic programming in C++.
• Kenneth Russell,David Detlefs,Eliminating synchronization-related atomic operations with biased locking and bulk rebiasing.
• George Fairbanks,David Garlan,William L. Scherlis,Design fragments make using frameworks easier.
• Jonas Maebe,Dries Buytaert,Lieven Eeckhout,Koen De Bosschere,Javana: a system for building customized Java program analysis tools.
• Chris Andreae,James Noble,Shane Markstrum,Todd D. Millstein,A framework for implementing pluggable type systems.
• Alex Potanin,James Noble,Dave Clarke,Robert Biddle,Generic ownership for generic Java.
• Stephen M. Blackburn,Robin Garner,Chris Hoffmann,Asjad M. Khan,Kathryn S. McKinley,Rotem Bentzur,Amer Diwan,Daniel Feinberg,Daniel Frampton,Samuel Z. Guyer,Martin Hirzel,Antony L. Hosking,Maria Jump,Han Bok Lee,J. Eliot B. Moss,Aashish Phansalkar,Darko Stefanovic,Thomas VanDrunen,Daniel von Dincklage,Ben Wiedermann,The DaCapo benchmarks: java benchmarking development and analysis.
• Kazunori Ogata,Tamiya Onodera,Kiyokuni Kawachiya,Hideaki Komatsu,Toshio Nakatani,Replay compilation: improving debuggability of a just-in-time compiler.
• Charles Simonyi,Magnus Christerson,Shane Clifford,Intentional software.
• Tal Cohen,Joseph Gil,Itay Maman,JTL: the Java tools language.
• Paul T. Darga,Chandrasekhar Boyapati,Efficient software model checking of data structure properties.
• Maurice Herlihy,Victor Luchangco,Mark Moir,A flexible framework for implementing software transactional memory.
• Nathaniel Nystrom,Xin Qi,Andrew C. Myers,J&: nested intersection for scalable software composition.
• Wei-Ngan Chin,Florin Craciun,Siau-Cheng Khoo,Corneliu Popeea,A flow-based approach for variant parametric types.

2005

• Simon Goldsmith,Robert O'Callahan,Alexander Aiken,Relational queries over program traces.
• Mangala Gowri Nanda,Christian Grothoff,Satish Chandra,Deriving object typestates in the presence of inter-object references.
• Sergei Kojarski,David H. Lorenz,Pluggable AOP: designing aspect mechanisms for third-party composition.
• J. Andrés Díaz Pace,Marcelo R. Campo,ArchMatE: from architectural styles to object-oriented models through exploratory tool support.
• Matthias Hauswirth,Amer Diwan,Peter F. Sweeney,Michael C. Mozer,Automating vertical profiling.
• Yanhong A. Liu,Scott D. Stoller,Michael Gorbovitski,Tom Rothamel,Yanni Ellen Liu,Incrementalization across object abstraction.
• Jonathan Edwards,Subtext: uncovering the simplicity of programming.
• Philippe Charles,Christian Grothoff,Vijay A. Saraswat,Christopher Donawa,Allan Kielstra,Kemal Ebcioglu,Christoph von Praun,Vivek Sarkar,X10: an object-oriented approach to non-uniform cluster computing.
• Yu David Liu,Scott F. Smith,Interaction-based programming with classages.
• Chris Allan,Pavel Avgustinov,Aske Simon Christensen,Laurie J. Hendren,Sascha Kuzins,Ondrej Lhoták,Oege de Moor,Damien Sereni,Ganesh Sittampalam,Julian Tibble,Adding trace matching with free variables to AspectJ.
• Ittai Balaban,Frank Tip,Robert M. Fuhrer,Refactoring support for class library migration.
• Glenn Vanderburg,A simple model of agile software processes - or - extreme programming annealed.
• Adam Welc,Suresh Jagannathan,Antony L. Hosking,Safe futures for Java.
• Martin Odersky,Matthias Zenger,Scalable component abstractions.
• Matthew Arnold,Adam Welc,V. T. Rajan,Improving virtual machine performance using a cross-run profile repository.
• Ajeet Shankar,S. Subramanya Sastry,Rastislav Bodík,James E. Smith,Runtime specialization with optimistic heap analysis.
• Alexandre Bergel,Stéphane Ducasse,Oscar Nierstrasz,Classbox/J: controlling the scope of change in Java.
• Andrew Kennedy,Claudio V. Russo,Generalized algebraic data types and object-oriented programming.
• Matthew Hertz,Emery D. Berger,Quantifying the performance of garbage collection vs. explicit memory management.
• Douglas Gregor,Andrew Lumsdaine,Lifting sequential graph algorithms for distributed-memory parallel computation.
• Antonio Cunei,Jan Vitek,PolyD: a flexible dispatching framework.
• Kathryn E. Gray,Robert Bruce Findler,Matthew Flatt,Fine-grained interoperability through mirrors and contracts.
• Neeraj Sangal,Ev Jordan,Vineet Sinha,Daniel Jackson,Using dependency models to manage complex software architecture.
• Matthew S. Tschantz,Michael D. Ernst,Javari: adding reference immutability to Java.
• Alexander Ahern,Nobuko Yoshida,Formalising Java RMI with explicit code mobility.
• Manu Sridharan,Denis Gopan,Lexin Shan,Rastislav Bodík,Demand-driven points-to analysis for Java.
• Joseph Gil,Itay Maman,Micro patterns in Java code.
• Michael C. Martin,V. Benjamin Livshits,Monica S. Lam,Finding application errors and security flaws using PQL: a program query language.
• Uwe Zdun,Paris Avgeriou,Modeling architectural patterns using architectural primitives.
• Cosmin E. Oancea,Stephen M. Watt,Parametric polymorphism for software component architectures.
• Marko van Dooren,Eric Steegmans,Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations.
• Jaakko Järvi,Jeremiah Willcock,Andrew Lumsdaine,Associated types and constraint propagation for mainstream object-oriented generics.

2004p

• Yann-Gaël Guéhéneuc,Hervé Albin-Amiot,Recovering binary class relationships: putting icing on the UML cake.
• David S. Goldberg,Robert Bruce Findler,Matthew Flatt,Super and inner: together at last!
• Westley Weimer,George C. Necula,Finding and preventing run-time error handling mistakes.
• Diab Abuaiadh,Yoav Ossia,Erez Petrank,Uri Silbershtein,An efficient parallel heap compaction algorithm.
• Nathaniel Nystrom,Stephen Chong,Andrew C. Myers,Scalable extensibility via nested inheritance.
• Gilad Bracha,David Ungar,Mirrors: design principles for meta-level facilities of object-oriented programming languages.
• Michael Factor,Assaf Schuster,Konstantin Shagin,Instrumentation of standard libraries in object-oriented languages: the twin class hierarchy approach.
• Alan Donovan,Adam Kiezun,Matthew S. Tschantz,Michael D. Ernst,Converting java programs to use generic libraries.
• Eric E. Allen,David Chase,Victor Luchangco,Jan-Willem Maessen,Guy L. Steele Jr.,Object-oriented units of measurement.
• Samuel Z. Guyer,Kathryn S. McKinley,Finding your cronies: static analysis for dynamic object colocation.
• Xianglong Huang,Stephen M. Blackburn,Kathryn S. McKinley,J. Eliot B. Moss,Zhenlin Wang,Perry Cheng,The garbage collection advantage: improving program locality.
• Mangala Gowri Nanda,Satish Chandra,Vivek Sarkar,Decentralizing execution of composite web services.
• Adrian Birka,Michael D. Ernst,A practical type system and language for reference immutability.
• Charles Zhang,Hans-Arno Jacobsen,Resolving feature convolution in middleware systems.
• Andy Georges,Dries Buytaert,Lieven Eeckhout,Koen De Bosschere,Method-level phase behavior in java workloads.
• Narendran Sachindran,J. Eliot B. Moss,Emery D. Berger,MC2: high-performance garbage collection for memory-constrained environments.
• Nathanael Schärli,Andrew P. Black,Stéphane Ducasse,Object-oriented encapsulation for dynamically typed languages.
• Polyvios Pratikakis,Jaime Spacco,Michael W. Hicks,Transparent proxies for java futures.
• Mirko Streckenbach,Gregor Snelting,Refactoring class hierarchies with KABA.
• David F. Bacon,Perry Cheng,V. T. Rajan,A unified theory of garbage collection.
• Bruno Dufour,Christopher Goard,Laurie J. Hendren,Oege de Moor,Ganesh Sittampalam,Clark Verbrugge,Measuring the dynamic behaviour of AspectJ programs.
• Daniel von Dincklage,Amer Diwan,Converting Java classes to use generics.
• Matthias Hauswirth,Peter F. Sweeney,Amer Diwan,Michael Hind,Vertical profiling: understanding the behavior of object-priented applications.
• Todd D. Millstein,Practical predicate dispatch.
• Xiaoxia Ren,Fenil Shah,Frank Tip,Barbara G. Ryder,Ophelia C. Chesley,Chianti: a tool for change impact analysis of java programs.
• Martin Bravenboer,Eelco Visser,Concrete syntax for objects: domain-specific language embedding and assimilation without restrictions.
• Philip W. L. Fong,Pluggable verification modules: an extensible protection mechanism for the JVM.

2003p

• Kazuaki Ishizaki,Mikio Takeuchi,Kiyokuni Kawachiya,Toshio Suganuma,Osamu Gohda,Tatsushi Inagaki,Akira Koseki,Kazunori Ogata,Motohiro Kawahito,Toshiaki Yasue,Takeshi Ogasawara,Tamiya Onodera,Hideaki Komatsu,Toshio Nakatani,Effectiveness of cross-platform optimizations for a java just-in-time compiler.
• Brian Demsky,Martin C. Rinard,Automatic detection and repair of errors in data structures.
• Guangyu Chen,Mahmut T. Kandemir,Narayanan Vijaykrishnan,Mary Jane Irwin,Bernd Mathiske,Mario Wolczko,Heap compression for memory-constrained Java environments.
• Darko Marinov,Robert O'Callahan,Object equality profiling.
• Todd D. Millstein,Mark Reay,Craig Chambers,Relaxed MultiJava: balancing extensibility and modular typechecking.
• Martin Hirzel,Amer Diwan,Matthew Hertz,Connectivity-based garbage collection.
• Narendran Sachindran,J. Eliot B. Moss,Mark-copy: fast copying GC with less space overhead.
• Andrew P. Black,Nathanael Schärli,Stéphane Ducasse,Applying traits to the smalltalk collection classes.
• David G. Clarke,Michael Richmond,James Noble,Saving the world from bad beans: deployment-time confinement checking.
• Philippe Mougin,Stéphane Ducasse,OOPAL: integrating array programming in object-oriented programming.
• Chandrasekhar Boyapati,Barbara Liskov,Liuba Shrira,Chuang-Hue Moh,Steven Richman,Lazy modular upgrades in persistent object stores.
• Manuel Fähndrich,K. Rustan M. Leino,Declaring and checking non-null types in an object-oriented language.
• Ronald Garcia,Jaakko Järvi,Andrew Lumsdaine,Jeremy G. Siek,Jeremiah Willcock,A comparative study of language support for generic programming.
• Eric E. Allen,Jonathan Bannet,Robert Cartwright,A first-class approach to genericity.
• Timothy L. Harris,Keir Fraser,Language support for lightweight transactions.
• Éric Tanter,Jacques Noyé,Denis Caromel,Pierre Cointe,Partial behavioral reflection: spatial and temporal selection of reification.
• John Corwin,David F. Bacon,David Grove,Chet Murthy,MJ: a rational module system for Java and its applications.
• Lieven Eeckhout,Andy Georges,Koenraad De Bosschere,How java programs interact with virtual machines at the microarchitectural level.
• Hezi Azatchi,Yossi Levanoni,Harel Paz,Erez Petrank,An on-the-fly mark and sweep garbage collector based on sliding views.
• Donal Lafferty,Vinny Cahill,Language-independent aspect-oriented programming.
• Keunwoo Lee,Anthony LaMarca,Craig Chambers,HydroJ: object-oriented pattern matching for evolvable distributed systems.
• Tian Zhao,Jens Palsberg,Jan Vitek,Lightweight confinement for featherweight Java.
• Bruno Dufour,Karel Driesen,Laurie J. Hendren,Clark Verbrugge,Dynamic metrics for java.
• Frank Tip,Adam Kiezun,Dirk Bäumer,Refactoring for generalization using type constraints.
• Stephen Blackburn,Kathryn S. McKinley,Ulterior reference counting: fast garbage collection without a long wait.
• Katherine Barabash,Yoav Ossia,Erez Petrank,Mostly concurrent garbage collection revisited.

2002

• Tony Printezis,Richard E. Jones,GCspy: an adaptable heap visualisation framework.
• Riccardo Pucella,Towards a formalization for COM part i: the primitive calculus.
• Dragos-Anton Manolescu,Workflow enactment with continuation and future objects.
• Kiyokuni Kawachiya,Akira Koseki,Tamiya Onodera,Lock reservation: Java locks can mostly do without atomic operations.
• Jan Hannemann,Gregor Kiczales,Design pattern implementation in Java and aspectJ.
• Karen Zee,Martin C. Rinard,Write barrier removal by static analysis.
• Larry Koved,Marco Pistoia,Aaron Kershenbaum,Access rights analysis for Java.
• Matthew Arnold,Michael Hind,Barbara G. Ryder,Online feedback-directed optimization of Java.
• Yefim Shuf,Manish Gupta,Hubertus Franke,Andrew W. Appel,Jaswinder Pal Singh,Creating and preserving locality of java applications at allocation and garbage collection times.
• Mira Mezini,Klaus Ostermann,Integrating independent components with on-demand remodularization.
• Sarfraz Khurshid,Darko Marinov,Daniel Jackson,An analyzable annotation language.
• Chandrasekhar Boyapati,Robert Lee,Martin C. Rinard,Ownership types for safe programming: preventing data races and deadlocks.
• Krzysztof Palacz,Jan Vitek,Grzegorz Czajkowski,Laurent Daynès,Incommunicado: efficient communication for isolates.
• Mikhail Dmitriev,Language-specific make technology for the Java programming language.
• Yoav Zibin,Joseph Gil,Fast algorithm for creating space efficient dispatching tables with application to multi-dispatching.
• Magnus E. Bjornsson,Liuba Shrira,BuddyCache: high-performance object storage for collaborative strong-consistency applications in a WAN.
• Sérgio Soares,Eduardo Laureano,Paulo Borba,Implementing distribution and persistence aspects with aspectJ.
• David G. Clarke,Sophia Drossopoulou,Ownership, encapsulation and the disjointness of type and effect.
• Rami Marelly,David Harel,Hillel Kugler,Multiple instances and symbolic variables in executable sequence charts.
• Jonathan Aldrich,Valentin Kostadinov,Craig Chambers,Alias annotations for program understanding.
• Emery D. Berger,Benjamin G. Zorn,Kathryn S. McKinley,Reconsidering custom memory allocation.
• Emmanuel Cecchet,Julie Marguerite,Willy Zwaenepoel,Performance and scalability of EJB applications.
• Bjorn De Sutter,Bruno De Bus,Koenraad De Bosschere,Sifting out the mud: low level C++ code reuse.
• Marc-Olivier Killijian,Juan-Carlos Ruiz-Garcia,Jean-Charles Fabre,Portable serialization of CORBA objects: a reflective approach.
• Laurent Michel,Pascal Van Hentenryck,A constraint-based architecture for local search.

2001

• Atanas Rountev,Ana Milanova,Barbara G. Ryder,Points-To Analysis for Java using Annotated Constraints.
• Yossi Levanoni,Erez Petrank,An On-the-Fly Reference Counting Garbage Collector for Java.
• Stephen Blackburn,Sharad Singhai,Matthew Hertz,Kathryn S. McKinley,J. Eliot B. Moss,Pretenuring for Java.
• Davide Ancona,Giovanni Lagorio,Elena Zucca,A Core Calculus for Java Exceptions.
• Dirk Riehle,Steven Fraleigh,Dirk Bucka-Lassen,Nosa Omorogbe,The Architecture of a UML Virtual Machine.
• Joost Visser,Visitor Combination and Traversal Control.
• Patrick Th. Eugster,Rachid Guerraoui,Christian Heide Damm,On Objects and Events.
• Jonathan Bachrach,Keith Playford,The Java Syntactic Extender.
• Robert Bruce Findler,Matthias Felleisen,Contract Soundness for Object-Oriented Languages.
• Dominic Duggan,Ching-Ching Techaubol,Modular Mixin-Based Inheritance for Application Frameworks.
• Mary Jean Harrold,James A. Jones,Tongyu Li,Donglin Liang,Alessandro Orso,Maikel Pennings,Saurabh Sinha,S. Alexander Spoon,Ashish Gujarathi,Regression Test Selection for Java Software.
• Grzegorz Czajkowski,Laurent Daynès,Multitasking without Compromise: A Virtual Machine Evolution.
• Chandrasekhar Boyapati,Martin C. Rinard,A Parameterized Type System for Race-Free Java Programs.
• Hiroaki Nakamura,Incremental Computation of Complex Objects Queries.
• Tim Brecht,Eshrat Arjomandi,Chang Li,Hang Pham,Controlling Garbage Collection and Heap Growth to Reduce the Execution Time of Java Applications.
• Toshio Suganuma,Toshiaki Yasue,Motohiro Kawahito,Hideaki Komatsu,Toshio Nakatani,A Dynamic Optimization Framework for a Java Just-In-Time Compiler.
• Klaus Ostermann,Mira Mezini,Object-Oriented Composition Untangled.
• Walter Binder,Jarle Hulaas,Alex Villazón,Portable Resource Control in Java: The J-SEAL2 Approach.
• Sean McDirmid,Matthew Flatt,Wilson C. Hsieh,Jiazzi: New-Age Components for Old-Fashioned Java.
• Takeshi Ogasawara,Hideaki Komatsu,Toshio Nakatani,A Study of Exception Handling and Its Dynamic Optimization in Java.
• Michele Lanza,Stéphane Ducasse,A Categorization of Classes based on the Visualization of their Internal Structure: The Class Blueprint.
• John Whaley,Partial Method Compilation using Dynamic Profile Information.
• Igor Pechtchanski,Vivek Sarkar,Dynamic Optimistic Interprocedural Analysis: A Framework and an Application.
• Christoph von Praun,Thomas R. Gross,Object Race Detection.
• Bowen Alpern,Anthony Cocchi,Stephen J. Fink,David Grove,Derek Lieber,Efficient Implementation of Java Interfaces: Invokeinterface Considered Harmless.
• Christian Grothoff,Jens Palsberg,Jan Vitek,Encapsulating Objects with Confined Types.
• Yoav Zibin,Joseph Gil,Efficient Subtyping Tests with PQ-Encoding.

2000

• Grzegorz Czajkowski,Application isolation in the JavaTM Virtual Machine.
• James Noble,David Holmes,John Potter,Exclusion for composite objects.
• Alvaro Ortigosa,Marcelo Campo,Roberto Moriyón,Towards agent-oriented assistance for framework instantiation.
• Rémi Bastide,Philippe A. Palanque,Ousmane Sy,David Navarre,Formal specification of CORBA services: experience and lessons learned.
• Kazuaki Ishizaki,Motohiro Kawahito,Toshiaki Yasue,Hideaki Komatsu,Toshio Nakatani,A study of devirtualization techniques for a JavaTM Just-In-Time compiler.
• Frank Tip,Jens Palsberg,Scalable propagation-based call graph construction algorithms.
• Ji Y. Lee,Hye J. Kim,Kyo Chul Kang,A real world object modeling method for creating simulation environment of real-time systems.
• Mikel Luján,T. L. Freeman,John R. Gurd,OoLALA: an object oriented analysis and design of numerical linear algebra.
• Mauricio J. Serrano,Rajesh Bordawekar,Samuel P. Midkiff,Manish Gupta,Quicksilver: a quasi-static compiler for Java.
• Matthew Arnold,Stephen J. Fink,David Grove,Michael Hind,Peter F. Sweeney,Adaptive optimization in the Jalapeño JVM.
• Clyde Ruby,Gary T. Leavens,Safely creating correct subclasses without seeing superclass code.
• Ayal Zaks,Vitaly Feldman,Nava Aizikowitz,Sealed calls in Java packages.
• Derek Rayside,Gerard T. Campbell,An Aristotelian understanding of object-oriented programming.
• William Harrison,Charles Barton,Mukund Raghavachari,Mapping UML designs to Java.
• David F. Bacon,Robert E. Strom,Ashis Tarafdar,Guava: a dialect of Java without data races.
• Ciarán Bryce,Chrislain Razafimahefa,An approach to safe object sharing.
• Jerry Kiernan,Michael J. Carey,Middleware object query processing with deferred updates and autonomous sources.
• Curtis Clifton,Gary T. Leavens,Craig Chambers,Todd D. Millstein,MultiJava: modular open classes and symmetric multiple dispatch for Java.
• Jan-Willem Maessen,Arvind,Xiaowei Shen,Improving the Java memory model using CRF.
• Peter A. Buhr,Ashif S. Harji,Philipp E. Lim,Jiongxiong Chen,Object-oriented real-time concurrency.
• Serge Demeyer,Stéphane Ducasse,Oscar Nierstrasz,Finding refactorings via change metrics.
• Neal Glew,An efficient class and object encoding.
• Zhenyu Qian,Allen Goldberg,Alessandro Coglio,A formal specification of JavaTM class loading.
• Stephan Herrmann,Mira Mezini,PIROL: a case study for multidimensional separation of concerns in software engineering environments.
• Vijay Sundaresan,Laurie J. Hendren,Chrislain Razafimahefa,Raja Vallée-Rai,Patrick Lam,Etienne Gagnon,Charles Godin,Practical virtual method call resolution for Java.
• Mirko Viroli,Antonio Natali,Parametric polymorphism in Java: an approach to translation based on reflective features.
• Mary Beth Rosson,Doug Lea,Proceedings of the 2000 ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages & Applications (OOPSLA 2000), Minneapolis, Minnesota, USA, October 15-19, 2000.

1999

• Craig Chambers,Weimin Chen,Efficient Multiple and Predicated Dispatching.
• Ran Rinat,Menachem Magidor,Scott F. Smith,Correspondence Polymorphism for Object-Oriented Languages.
• Ilya Lipkind,Igor Pechtchanski,Vijay Karamcheti,Object Views: Language Support for Intelligent Object Caching in Parallel and Distributed Computations.
• Frank Tip,Chris Laffra,Peter F. Sweeney,David Streeter,Practical Experience with an Application Extractor for Java.
• Elizabeth A. Kendall,Role Model Designs and Implementations with Aspect-oriented Programming.
• Jong-Deok Choi,Manish Gupta,Mauricio J. Serrano,Vugranam C. Sreedhar,Samuel P. Midkiff,Escape Analysis for Java.
• Siobhán Clarke,William H. Harrison,Harold Ossher,Peri L. Tarr,Subject-Oriented Design: Towards Improved Alignment of Requirements, Design, and Code.
• Jan Vitek,Boris Bokowski,Confined Types.
• Chandra Krintz,Brad Calder,Urs Hölzle,Reducing Transfer Delay Using Java Class File Splitting and Prefetching.
• Huw Evans,Peter Dickman,Zones, Contracts and Absorbing Changes: An Approach to Software Evolution.
• Tamiya Onodera,Kiyokuni Kawachiya,A Study of Locking Objects with Bimodal Fields.
• Guilherme Travassos,Forrest Shull,Michael Fredericks,Victor R. Basili,Detecting Defects in Object-Oriented Designs: Using Reading Techniques to Increase Software Quality.
• Leila Ismail,Daniel Hagimont,A Performance Evaluation of the Mobile Agent Paradigm.
• Stephen N. Freund,John C. Mitchell,A Formal Framework for the Java Bytecode Language and Verifier.
• Brent Hailpern,Linda M. Northrop,A. Michael Berman,Proceedings of the 1999 ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages & Applications (OOPSLA '99), Denver, Colorado, USA, November 1-5, 1999.
• Bruno Blanchet,Escape Analysis for Object-Oriented Languages: Application to Java.
• Atsushi Igarashi,Benjamin C. Pierce,Philip Wadler,Featherwieght Java: A Minimal Core Calculus for Java and GJ.
• Ole Lehrmann Madsen,Semantic Analysis of Virtual Classes and Tested Classes.
• Antony L. Hosking,Jiawan Chen,Mostly-copying Reachability-based Orthogonal Persistence.
• Lie-Quan Lee,Jeremy G. Siek,Andrew Lumsdaine,The Generic Graph Component Library.
• Bowen Alpern,C. Richard Attanasio,John J. Barton,Anthony Cocchi,Susan Flynn Hummel,Derek Lieber,Ton Ngo,Mark F. Mergen,Janice C. Shepherd,Stephen E. Smith,Implementing Jalapeño in Java.
• Jeff Bogda,Urs Hölzle,Removing Unnecessary Synchronization in Java.
• Darko Stefanovic,Kathryn S. McKinley,J. Eliot B. Moss,Age-Based Garbage Collection.
• Johan Ovlinger,Mitchell Wand,A Language for Specifying Recursive Traversals of Object Structures.
• Avelino F. Zorzo,Robert J. Stroud,A Distributed Object-Oriented Framework for Dependable Multiparty Interactions.
• Dominic Duggan,Modular Type-Based Reverse Engineering of Parameterized Types in Java Code.
• Robert B. France,A Problem-Oriented Analysis of Basic UML Static Requirements Modeling Concepts.
• Ole Agesen,David Detlefs,Alex Garthwaite,Ross Knippel,Y. S. Ramakrishna,Derek White,An Efficient Meta-Lock for Implementing Ubiquitous Synchronization.
• Mik Kersten,Gail C. Murphy,Atlas: A Case Study in Building a Web-Based Learning Environment using Aspect-oriented Programming.
• John Whaley,Martin C. Rinard,Compositional Pointer and Escape Analysis for Java Programs.
• Peter F. Sweeney,Joseph Gil,Space and Time-Efficient Memory Layout for Multiple Inheritance.

1998

• Ellen Agerbo,Aino Cornils,How to Preserve the Benefits of Design Patterns.
• Mark L. McAuliffe,Michael J. Carey,Marvin H. Solomon,Vclusters: A Flexible, Fine-Grained Object Clustering Mechanism.
• Mira Mezini,Karl J. Lieberherr,Adaptive Plug-and-Play Components for Evolutionary Software Development.
• Steven Fraser,Maggie Davis,Martin L. Griss,Luke Hohmann,Ian Hopper,Rebecca Joos,Bill Opdyke,Software Reuse: Nemesis or Nirvana? (Panel).
• Vassily Litvinov,Contraint-Based Polymorphism in Cecil: Towards a Practical and Static Type System.
• Grzegorz Czajkowski,Thorsten von Eicken,JRes: A Resource Accounting Interface for Java.
• Lars Bak,John Duimovich,Jesse Fang,Scott Meyer,David Ungar,The New Crop of Java Virtual Machines (Panel).
• Bjørn N. Freeman-Benson,Craig Chambers,Proceedings of the 1998 ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages & Applications (OOPSLA '98), Vancouver, British Columbia, Canada, October 18-22, 1998.
• Alistair Cockburn,Martin Fowler,Question time! about Use Cases.
• David G. Clarke,John Potter,James Noble,Ownership Types for Flexible Alias Protection.
• Sheng Liang,Gilad Bracha,Dynamics Class Loading in the Java Virtual Machine.
• Frank Olken,Hans-Arno Jacobsen,Chuck McParland,Mary Ann Piette,Mary F. Anderson,Object Lessons Learned from a Distributed System for Remote Building Monitoring and Operation.
• Martin Büchi,Wolfgang Weck,Compound Types for Java.
• Noury M. N. Bouraqadi-Saâdani,Thomas Ledoux,Fred Rivard,Safe Metaclass Programming.
• Robert Cartwright,Guy L. Steele Jr.,Compatible Genericity with Run-Time Types for the Java Programming Language.
• Gary T. Leavens,Todd D. Millstein,Multiple Dispatch as Dispatch on Tuples.
• Stephen N. Freund,John C. Mitchell,A Type System for Object Initialization in the Java Bytecode Language.
• Julian Dolby,Andrew A. Chien,An Evaluation of Automatic Object Inline Allocation Techniques.
• Jose Solorzano,Suad Alagic,Parametric Polymorphism for Java: A Reflective Solution.
• Elisa Bertino,Giovanna Guerrini,Extending the ODMG Object Model with Composite Objects.
• Pietro Di Gianantonio,Furio Honsell,Luigi Liquori,A Lambda Calculus of Objects with Self-Inflicted Extension.
• Bart Jacobs,Joachim van den Berg,Marieke Huisman,Martijn van Berkum,Reasoning about Java Classes (Preliminary Report).
• Dirk Riehle,Thomas R. Gross,Role Model Based Framework Design and Integration.
• Jacob Harris,Vivek Sarkar,Lightweight Object-Oriented Shared Variables for Distributed Applications on the Internet.
• Anthony J. H. Simons,Borrow, Copy or Steal? Loans and Larceny in the Orthodox Canonical Form.
• Doug Lea,David W. Forslund,Tom Barry,Don Vines,Rajendra K. Raj,Ashutosh Tiwary,Building Distributed Systems (Panel).
• K. Rustan M. Leino,Data Groups: Specifying the Modification of Extended State.
• Gilad Bracha,Martin Odersky,David Stoutamire,Philip Wadler,Making the Future Safe for the Past: Adding Genericity to the Java Programming Language.
• Sophia Drossopoulou,David Wragg,Susan Eisenbach,What is Java Binary Compatibility?
• Rachid Guerraoui,Pascal Felber,Benoît Garbinato,Karim Mazouni,System Support for Object Groups.
• Jonathan G. Rossie Jr.,Logical Observable Entities.
• Robert J. Walker,Gail C. Murphy,Bjørn N. Freeman-Benson,Darin Wright,Darin Swanson,Jeremy Isaak,Visualizing Dynamic Software System Information Through High-Level Models.

1997

• Michael J. Franklin,Stanley B. Zdonik,A Framework for Scalbale Dissemination-Based Systems.
• Frank Tip,Peter F. Sweeney,Class Hierarchy Specialization.
• Jan Vitek,R. Nigel Horspool,Andreas Krall,Efficient Type Inclusion Tests.
• Timothy H. Harrison,David L. Levine,Douglas C. Schmidt,The Design and Performance of a Hard Real-Time Object Event Service.
• Matthew Haines,An Open Implementation Analysis and Design for Lightweight Threads.
• Raimondas Lencevicius,Urs Hölzle,Ambuj K. Singh,Query-Based Debugging of Object-Oriented Programs.
• Richard L. Hudson,Ronald Morrison,J. Eliot B. Moss,David S. Munro,Garbage Collecting the World: One Car at a Time.
• Margaretha W. Price,Steven A. Demurjian,Analyzing and Measuring Reusability in Object-Oriented Designs.
• David Grove,Greg DeFouw,Jeffrey Dean,Craig Chambers,Call Graph Construction in Object-Oriented Languages.
• Diane J. Litman,Anil Mishra,Peter F. Patel-Schneider,Modeling Dynamic Collections of Interdependent Objects Using Path-Based Rules.
• Dan Ingalls,Ted Kaehler,John Maloney,Scott Wallace,Alan C. Kay,Back to the Future: The Story of Squeak - A Usable Smalltalk Written in Itself.
• Jon R. Oler,Gary Lindstrom,Terence Critchlow,Migrating Relational Data to an OODB: Strategies and Lessons from a Molecular Biology Experience.
• Barry Hayes,Ephemerons: A New Finalization Mechanism.
• Mira Mezini,Maintaining the Consistency of Class Libraries During Their Evolution.
• Ole Agesen,Stephen N. Freund,John C. Mitchell,Adding Type Parameterization to the Java Language.
• Dirk Riehle,Composite Design Patterns.
• David H. Lorenz,Tiling Design Patterns - A Case Study Using the Interpreter Pattern.
• Karsten Weihe,Reuse of Algorithms: Still a Challenge to Object-Oriented Programming.
• Eugen-Nicolae Volanschi,Charles Consel,Gilles Muller,Crispin Cowan,Declarative Specialization of Object-Oriented Programs.
• John Boyland,Giuseppe Castagna,Parasitic Methods: An Implementation of Multi-Methods for Java.
• Stuart Kent,Constraint Diagrams: Visualizing Assertions in Object-Oriented Models.
• Olivier Zendra,Dominique Colnet,Suzanne Collin,Efficient Dynamic Dispatch without Virtual Function Tables: The SmallEiffel Compiler.
• Suad Alagic,The ODMG Object Model: Does it Make Sense?

1996

• Amer Diwan,J. Eliot B. Moss,Kathryn S. McKinley,Simple and Effective Analysis of Statically Typed Object-Oriented Programs.
• Evan Wallace,Kurt C. Wallnau,A Situated Evaluation of the Object Management Group's (OMG) Object Management Architecture (OMA).
• Hervé Dicky,Christophe Dony,Marianne Huchard,Thérèse Libourel,On Automatic Class Insertion with Overloading.
• Nils Klarlund,Jari Koistinen,Michael I. Schwartzbach,Formal Design Constraints.
• Joseph Gil,David H. Lorenz,Environmental Acquisition - A New Inheritance-Like Abstraction Mechanism.
• Jan Kleindienst,Frantisek Plasil,Petr Tuma,Lessons Learned from Implementing the CORBA Persistent Object Service.
• Susumu Nishimura,Atsushi Ohori,Keishi Tajima,An Equational Object-Oriented Data Model and its Data-Parallel Query Language.
• Allen H. Dutoit,Sean Levy,Douglas Cunningham,Robert Patrick,The Basic Object System: Supporting a Spectrum From Prototypes To Hardened Code.
• Hernán Astudillo,Reorganizing Split Objects.
• Earl F. Ecklund Jr.,Lois M. L. Delcambre,Michael J. Freiling,Change Cases: Use Cases that Identify Future Requirements.
• Saniya Ben Hassen,Irina Athanasiu,Henri E. Bal,A Flexible Operation Execution Model for Shared Distributed Objects.
• Phillip M. Yelland,Creating Host Compliance in a Portable Framework: A Study in the Use of Existing Design Patterns.
• Ivan Moore,Automatic Inheritance Hierarchy Restructuring and Method Refactoring.
• Jeffrey Dean,Greg DeFouw,David Grove,Vassily Litvinov,Craig Chambers,Vortex: An Optimizing Compiler for Object-Oriented Languages.
• David F. Bacon,Peter F. Sweeney,Fast Static Analysis of C++ Virtual Function Calls.
• Daniel Bardou,Christophe Dony,Split Objects: a Disciplined Use of Delegation within Objects.
• Ali-Reza Adl-Tabatabai,Thomas R. Gross,Guei-Yuan Lueh,Code Reuse in an Optimizing Compiler.
• Ralf Möller,A Functional Layer for Description Logics: Knowledge Representation Meets Object-Oriented Programing.
• Frank Tip,Jong-Deok Choi,John Field,G. Ramalingam,Slicing Class Hierarchies in C++.
• Mohlalefi Sefika,Aamod Sane,Roy H. Campbell,Architecture-Oriented Visualization.
• Michael VanHilst,David Notkin,Using Role Components to Implement Collaboration-Based Designs.
• Kim Barrett,Bob Cassels,Paul Haahr,David A. Moon,Keith Playford,P. Tucker Withington,A Monotonic Superclass Linearization for Dylan.
• Patrick Steyaert,Carine Lucas,Kim Mens,Theo D'Hondt,Reuse Contracts: Managing the Evolution of Reusable Assets.
• Karel Driesen,Urs Hölzle,The Direct Cost of Virtual Function Calls in C++.
• Alan M. Durham,Ralph E. Johnson,A Framework for Run-Time Systems and its Visual Programming Language.

1995

• Matthew Haines,Piyush Mehrotra,John Van Rosendale,SmartFiles: An OO Approach to Data File Interoperabilty.
• Shigeru Chiba,A Metaobject Protocol for C++.
• Hermann Hüni,Ralph E. Johnson,Robert Engel,A Framework for Network Protocol Software.
• Jerry Kiernan,Michael J. Carey,Extending SQL-92 for OODB Access: Design and Implementation Experience.
• Arthur Allen,Dennis de Champeaux,Extending the Statechart Formalism: Event Scheduling & Disposition.
• Danny B. Lange,Yuichi Nakamura,Interactive Visualization of Design Patterns Can Help in Framework Understanding.
• Stéphane Ducasse,Mireille Blay-Fornarino,Anne-Marie Pinna-Dery,A Reflective Model for First Class Dependencies.
• Philippe Mulet,Jacques Malenfant,Pierre Cointe,Towards a Methodology for Explicit Composition of MetaObjects.
• Jonathan Eifrig,Scott F. Smith,Valery Trifonov,Sound Polymorphic Type Inference for Objects.
• Harold Ossher,Matthew Kaplan,William H. Harrison,Alexander Katz,Vincent J. Kruskal,Subject-Oriented Composition Rules.
• Dirk Riehle,How and Why to Encapsulate Class Trees.
• Andrew C. Myers,Bidirectional Object Layout for Separate Compilation.
• Karel Driesen,Urs Hölzle,Minimizing Row Displacement Dispatch Tables.
• Jonathan G. Rossie Jr.,Daniel P. Friedman,An Algebraic Semantics of Subobjects.
• Don Baron,Tom Arnold,Evolving to Objects - The Witches' Brew.
• Thomas P. Vajda,Lessons from the Battlefield.
• Anders Kristensen,Colin Low,Problem-Oriented Object Memory: Customizing Consistency.
• Ruth Malan,Derek Coleman,Reed Letsinger,Lessons from the Experiences of Leading-Edge Object Technology Projects in Hewlett Packard.
• Aamod Sane,Roy H. Campbell,Object-Oriented State Machines: Subclassing, Composition, Delegation and Genericity.
• Hans Albrecht Schmid,Creating the Architecture of a Manufacturing Framework by Design Patterns.
• Ole Agesen,Urs Hölzle,Type Feedback vs. Concrete Type Inference: A Comparison of Optimization Techniques for Object-Oriented Languages.
• David Grove,Jeffrey Dean,Charles Garrett,Craig Chambers,Profile-Guided Receiver Class Prediction.
• Jun-ichiro Itoh,Yasuhiko Yokote,Mario Tokoro,SCONE: Using Concurrent Objects for Low-level Operating System Programming.
• Mark Day,Robert Gruber,Barbara Liskov,Andrew C. Myers,Subtypes vs. Where Clauses: Constraining Parametric Polymorphism.
• Richard Helm,Patterns in Practice.
• Hidehiko Masuhara,Satoshi Matsuoka,Kenichi Asai,Akinori Yonezawa,Compiling Away the Meta-Level in Object-Oriented Concurrent Reflective Languages Using Partial Evaluation.
• Jacques Malenfant,On the Semantic Diversity of Delegation-Based Programming Languages.
• Randall B. Smith,John Maloney,David Ungar,The Self-4.0 User Interface: Manifesting a System-wide Vision of Concreteness, Uniformity and Flexibility.
• Ira R. Forman,Michael H. Conner,Scott Danforth,Larry K. Raper,Release-to-Release Binary Compatibility in SOM.
• Walter R. Smith,Using a Prototype-based Language for User Interface: The Newton Project's Experience.
• David Ungar,Annotating Objects for Transport to Other Worlds.
• Raymie Stata,John V. Guttag,Modular Reasoning in the Presence of Subclassing.

1994

• Naoki Kobayashi,Akinori Yonezawa,Type-Theoretic Foundations for Concurrent Object-Oriented Programming.
• Ole Agesen,David Ungar,Sifting Out the Gold.
• Bent Bruun Kristensen,Complex Associations: Abstractions in Object-Oriented Modeling.
• Tamiya Onodera,Experience with Representing C++ Program Information in an Object-Oriented Database.
• Daniel Hagimont,Pierre-Yves Chevalier,André Freyssinet,Sacha Krakowiak,Serge Lacourte,Jacques Mossière,Xavier Rousset de Pina,Persistent Shared Object Support in the Guide System: Evaluation & Related Work.
• Kaj Grønbæk,Jawahar Malhotra,Building Tailorable Hypermedia Systems: The Embedded-Interpreter Approach.
• Raymond J. A. Buhr,Ronald S. Casselman,Timethread-Role Maps for Object-Oriented Design of Real-Time-and-Distributed Systems.
• Richard Jordan,Ruth Smilan,Alex Wilkinson,Streamlining the Project Cycle With Object-Oriented Requirements.
• Jean-Yves Vion-Dury,Miguel Santana,Virtual Images: Interactive Visualization of Distributed Object-Oriented Systems.
• Ira R. Forman,Scott Danforth,Hari Madduri,Composition of Before/After Metaclasses in SOM.
• Phillip Bogle,Barbara Liskov,Reducing Cross Domain Call Overhead using Batched Futures.
• Eric Amiel,Olivier Gruber,Eric Simon,Optimizing Multi-Method Dispatch Using Compressed Dispatch Tables.
• Isabelle Puaut,A Distributed Garbage Collector for Active Objects.
• John F. Karpovich,Andrew S. Grimshaw,James C. French,Extensible File Systems (ELFS): An Object-Oriented Approach to High Performance File I/O.
• Jonathan Eifrig,Scott F. Smith,Valery Trifonov,Amy E. Zwarico,Application of OOP Type Theory: State, Decidability, Integragtion.
• Michael J. Carey,David J. DeWitt,Chander Kant,Jeffrey F. Naughton,A Status Report on the oo7 OODBMS Benchmarking Effort.
• Scott Danforth,Ira R. Forman,Reflections on Metaclass Rorgramming in SOM.
• Ed Seidewitz,Genericity versus Inheritance Reconsidered: Self-Reference Using Generics.
• Rodolfo F. Resende,Divyakant Agrawal,Amr El Abbadi,Semantic Locking in Object-Oriented Database Systems.
• Urs Hölzle,David Ungar,A Third-Generation SELF Implementation: Reconsiling Responsiveness with Performance.
• Darryl James Rothering,Development of an OO Infrastructure for Mainframe Database Applications.
• Gus Lopez,Bjørn N. Freeman-Benson,Alan Borning,Implementing Constraint Imperative Programming Languages: The Kaleidospace'93 Virtual Machine.
• Roland Ducournau,Michel Habib,Marianne Huchard,Marie-Laure Mugnier,Proposal for a Monotonic Multiple Inheritance Linearization.
• Bob Beck,Steve Hartley,Persistent Storgage for a Workflow Tool Implemented in Smalltalk.
• Victor B. Lortz,Kang G. Shin,Combining Contracts and Exemplar-Based Programming for Class Hiding and Customization.
• Scott P. Robertson,John M. Carroll,Robert L. Mack,Mary Beth Rosson,Sherman R. Alpert,Jürgen Koenemann-Belliveau,ODE: A Self-Guided, Scenario-Based Learning Environment for Object-Oriented Design Principles.
• Daniel M. Yellin,Robert E. Strom,Interfaces, Protocols, and the Semi-Automatic Construction of Software Adaptors.
• John Plevyak,Andrew A. Chien,Precise Concrete Type Inference for Object-Oriented Languages.
• Craig Chambers,Gary T. Leavens,Typechecking and Modules for Multi-Methods.
• Andrea Spinelli,Paolo Salvaneschi,Mauro Cadei,Marino Rocca,MI - An Object Oriented Environment for Integration of Scientific Applications.

1993

• Franz J. Hauck,Inheritance Modeled with Explicit Bindings: An Approach to Typed Inheritance.
• Tim Bingham,Nancy Hobbs,Dave Husson,Experiences Developing and Using an Object-Oriented Library for Program Manipulation.
• Keith Krueger,David Loftesness,Amin Vahdat,Thomas E. Anderson,Tools for the Development of Application-Specific Virtual Memory Management.
• Satoshi Matsuoka,Kenjiro Taura,Akinori Yonezawa,Highly Efficient and Encapsulated Re-use of Synchronization Code in Concurrent Object-Oriented Languages.
• William H. Harrison,Harold Ossher,Subject-Oriented Programming (A Critique of Pure Objects).
• S. Tucker Taft,Ada 9X: From Abstraction-Oriented to Object-Oriented.
• Henri E. Bal,M. Frans Kaashoek,Object Distribution in Orca using Compile-Time and Run-Time Techniques.
• Karel Driesen,Selector Table Indexing & Sparse Arrays.
• Franco Civello,Roles for Composite Objects in Object-Oriented Analysis and Design.
• Larry Koved,Wayne L. Wooten,GROOP: An Object-Oriented Toolkit for Animated 3D Graphics.
• Toshimi Minoura,Shirish S. Pargaonkar,Kurt Rehfuss,Structural Active Object Systems for Simulation.
• Bernd Bruegge,Tim Gottschalk,Bin Luo,A Framework for Dynamic Program Analyzers.
• Kim B. Bruce,Jonathan Crabtree,Thomas P. Murtagh,Robert van Gent,Allyn Dimock,Robert Muller,Safe and Decidable Type Checking in an Object-Oriented Language.
• Barbara Liskov,Jeannette M. Wing,Specifications and Their Use in Defining Subtypes.
• John Lamping,Typing the Specialization Interface.
• Vinny Cahill,Seán Baker,Chris Horn,Gradimir Starovic,The Amadeus GRT - Generic Runtime Support for Distributed Persistent Programming.
• Paul S. Strauss,IRIS Inventor, A 3D Graphics Toolkit.
• Gilad Bracha,David Griswold,Strongtalk: Typechecking Smalltalk in a Production Environment.
• Mohammed H. Odeh,Julian A. Padget,Object-Oriented Execution of OPS5 Production Systems.
• Robert Godin,Hafedh Mili,Building and Maintaining Analysis-Level Class Hierarchies Using Galois Lattices.
• Wim De Pauw,Richard Helm,Doug Kimelman,John M. Vlissides,Visualizing the Behavior of Object-Oriented Systems.
• Michael Stark,Impacts of Object-Oriented Technologies: Seven Years of SEL Studies.
• Oscar Nierstrasz,Regular Types for Active Objects.
• Yves Caseau,Efficient Handling of Multiple Inheritance Hierarchies.
• Antony L. Hosking,J. Eliot B. Moss,Object Fault Handling for Persistent Programming Languages: A Performance Evaluation.
• Laxmikant V. Kalé,Sanjeev Krishnan,CHARM++: A Portable Concurrent Object Oriented System Based On C++.
• Geir Magne Høydalsvik,Guttorm Sindre,On the Purpose of Object-Oriented Analysis.

1992

• Gregor Kiczales,John Lamping,Issues in the Design and Documentation of Class Libraries.
• Brad A. Myers,Dario A. Giuse,Brad T. Vander Zanden,Declarative Programming in a Prototype-Instance System: Object-Oriented Programming Without Writing Methods.
• Jeffrey S. Chase,Henry M. Levy,Edward D. Lazowska,Miche Baker-Harvey,Lightweight Shared Objects in a 64-Bit Operating System.
• Raymond J. A. Buhr,Ronald S. Casselman,Architectures with Pictures.
• Christophe Dony,Jacques Malenfant,Pierre Cointe,Prototype-Based Languages: From a New Taxonomy to Constructive Proposals and Their Validation.
• William R. Cook,Interfaces and Specifications for the Smalltalk-80 Collection Classes.
• Ralph E. Johnson,Documenting Frameworks using Patterns.
• Ichiro Satoh,Mario Tokoro,A Formalism for Real-Time Concurrent Object-Oriented Computing.
• Dennis de Champeaux,Doug Lea,Penelope Faure,The Process of Object-Oriented Design.
• Klaus-Peter Löhr,Concurrency Annotations.
• Roland Ducournau,Michel Habib,Marianne Huchard,Marie-Laure Mugnier,Monotonic Conflict Resolution Mechanisms for Inheritance.
• James F. Walsh,Preliminary Defect Data from the Iterative Development of a Large C++ Program.
• Hidehiko Masuhara,Satoshi Matsuoka,Takuo Watanabe,Akinori Yonezawa,Object-Oriented Concurrent Reflective Languages can be Implemented Efficiently.
• Antony L. Hosking,J. Eliot B. Moss,Darko Stefanovic,A Comparative Performance Evaluation of Write Barrier Implementations.
• Yasuhiko Yokote,The Apertos Reflective Operating System: The Concept and its Implementation.
• Dennis de Champeaux,Al Anderson,Ed Feldhousen,Case Study of Object-Oriented Software Development.
• Joel E. Richardson,Peter M. Schwarz,Luis-Felipe Cabrera,CACL: Efficient Fine-Grained Protection for Objects.
• Stephen W. Clyde,David W. Embley,Scott N. Woodfield,Tunable Formalism in Object-Oriented Systems Analysis: Meeting the Needs of Both Theoreticians and Practitioners.
• Bruce Horn,Constraint Patterns As a Basis for Object-Oriented Programming.
• Chamond Liu,Stephen Goetze,Bill Glynn,What Contributes to Successful Object-Oriented Learning?
• Kazunori Takashio,Mario Tokoro,DROL: An Object-Oriented Programming Language for Distributed Real-Time Systems.
• Yutaka Ishikawa,Communication Mechanism on Autonomous Objects.
• Pascal André,Jean-Claude Royer,Optimizing Method Search with Lookup Caches and Incremental Coloring.
• Phillip M. Yelland,Experimental Classification Facilities for Smalltalk.
• Paul R. Calder,Mark A. Linton,The Object-Oriented Implementation of a Document Editor.
• Michael J. Feeley,Henry M. Levy,Distributed Shared Memory with Versioned Objects.
• Michael F. Wangler,Peeter Hansen,Visualizing Objects: Methods for Exploring Human Computer Interaction Concepts.
• Harold Ossher,William H. Harrison,Combination of Inheritance Hierarchies.
• Mehmet Aksit,Lodewijk Bergmans,Obstacles in Object-Oriented Software Development.
• Bernd Bruegge,Jim Blythe,Jeffrey C. Jackson,Jeff Shufelt,Object-Oriented System Modeling with OMT.
• Thomas Eggenschwiler,Erich Gamma,ET++ Swaps Manager: Using Object Technology in the Financial Engineering Domain.

1991

• Jean-Marc Andreoli,Remo Pareschi,Communication as Fair Distribution of Knowledge.
• Rakesh Agrawal,Linda G. DeMichiel,Bruce G. Lindsay,Static Type Checking of Multi-Methods.
• Alan Snyder,How to Get Your Paper Accepted at OOPSLA.
• Paul L. Bergstein,Object-Preserving Class Transformations.
• Fiona Hayes,Derek Coleman,Coherent Models for Object-Oriented Analysis.
• Michael R. Wilk,Equate: An Object-Oriented Constraint Solver.
• Ravi Sharma,Mary Lou Soffa,Parallel Generational Garbage Collection.
• John A. Lewis,Sallie M. Henry,Dennis G. Kafura,Robert S. Schulman,An Empirical Study of the Object-Oriented Paradigm and Software Reuse.
• Eric Gold,Mary Beth Rosson,Portia: AN Instance-Centered Environment for Smalltalk.
• Rahim Yaseen,Stanley Y. W. Su,Herman Lam,An Extensible Kernel Object Management System.
• Giorgio Ghelli,A Static Type System for Message Passing.
• Sergui S. Simmel,Ivan Godard,The Kala Basket: A Semantic Primitive Unifying Object Transactions, Access Control, Versions, and Configurations.
• Jens Palsberg,Michael I. Schwartzbach,Object-Oriented Type Inference.
• Shyam R. Chidamber,Chris F. Kemerer,Towards a Metrics Suite for Object Oriented Design.
• Richard Helm,Yoëlle S. Maarek,Integrating Information Retrieval and Domain Specific Approaches for Browsing and Retrieval in Object-Oriented Class Libraries.
• Eric N. Hanson,Tina M. Harvey,Mark A. Roth,Experiences in DBMS Implementation Using an Object-Oriented Persistent Programming Language and a Database Toolkit.
• Joseph A. Konstan,Lawrence A. Rowe,Developing a GUIDE Using Object-Oriented Programming.
• Simon J. Gibbs,Composite Multimedia and Active Objects.
• Nuno Guimarães,Building Generic User Interface Tools: an Experience with Multiple Inheritance.
• Craig Chambers,David Ungar,Making Pure Object-Oriented Languages Practical.
• Dan Benson,Greg Zick,Symbolic and Spatial Database for Structural Biology.
• Ivar Jacobson,Fredrik Lindström,Re-engineering of Old Systems to an Object-Oriented Database.
• Barry Hayes,Using Key Object Opportunism to Collect Old Objects.
• John Hogg,Islands: Aliasing Protection in Object-Oriented Languages.

1990

• Dennis G. Kafura,Douglas Washabaugh,Jeff Nelson,Garbage Collection of Actors.
• José Meseguer,A Logical Theory of Concurrent Objects.
• Barbara Staudt Lerner,A. Nico Habermann,Beyond Schema Evolution to Database Reorganization.
• Lucy M. Berlin,When Objects Collide: Experiences with Reusing Multiple Class Hierarchies.
• Yen-Ping Shan,MoDE: A UIMS for Smalltalk.
• Jean-Marc Andreoli,Remo Pareschi,LO and Behold! Concurrent Structured Processes.
• Christophe Dony,Exception Handling and Object-Oriented Programming: Towards a Synthesis.
• John E. Faust,Henry M. Levy,The Performance of an Object-Oriented Threads Package.
• Jens Palsberg,Michael I. Schwartzbach,Type Substitution for Object-Oriented Programming.
• Bjørn N. Freeman-Benson,Kaleidoscope: Mixing Objects, Constraints and Imperative Programming.
• Oscar Nierstrasz,Michael Papathomas,Viewing Objects as Patterns of Communicating Agents.
• Sabine Habert,Vadim Abrossimov,COOL: Kernel Support for Object-Oriented Environments.
• Yutaka Ishikawa,Hideyuki Tokuda,Clifford W. Mercer,Object-Oriented Real-Time Language Design: Constructs for Timing Constraints.
• John Alan McDonald,Werner Stuetzle,Andreas Buja,Painting Multiple Views of Complex Objects.
• Stephen Bear,Phillip Allen,Derek Coleman,Fiona Hayes,Graphical Specification of Object-Oriented Systems.
• Andreas Paepcke,PCLOS: Stress Testing CLOS Experiencing the Metaobject Protocol.
• Sanjiv Gossain,Bruce Anderson,An Iterative-Design Model for Reusable Object-Oriented Software.
• Bernard Carré,Jean-Marc Geib,The Point of View Notion for Multiple Inheritance.
• Kenneth M. Kahn,Vijay A. Saraswat,Actors as a Special Case of Concurrent Constraint Programming.
• Gary T. Leavens,William E. Weihl,Reasoning about Object-Oriented Programs that Use Subtypes.
• Ole Lehrmann Madsen,Boris Magnusson,Birger Møller-Pedersen,Strong Typing of Object-Oriented Languages Revisited.
• Grady Booch,Michael Vilot,The Design of the C++ Booch Components.
• Pierre America,Frank van der Linden,A Parallel Object-Oriented Language with Inheritance and Subtyping.
• Dave D. Straube,M. Tamer Özsu,Type Consistency of Queries in an Object-Oriented Database System.
• Richard Helm,Ian M. Holland,Dipayan Gangopadhyay,Contracts: Specifying Behavioural Compositions in Object-Oriented Systems.
• Gilad Bracha,William R. Cook,Mixin-based Inheritance.
• Hans-Dieter Böcker,Jürgen Herczeg,What Tracers Are Made Of.
• Volker Haarslev,Ralf Möller,A Framework for Visualizing Object-Oriented Systems.
• Jan A. Purchase,Russel L. Winder,Message Pattern Specifications: A New Technique for Handling Errors in Parallel Object Oriented Systems.

1989

• Claus H. Pedersen,Extending Ordinary Inheritance Schemes to Include Generalization.
• Sandra S. Walther,Richard L. Peskin,Strategies for Scientific Prototyping in Smalltalk.
• Karl J. Lieberherr,Arthur J. Riel,Contributions to Teaching Object Oriented Design and Programming.
• Walter C. Dietrich Jr.,Lee R. Nackman,Franklin Gracer,Saving a Legacy With Objects.
• Rebecca Wirfs-Brock,Brian Wilkerson,Object-Oriented Design: A Responsibility-Driven Approach.
• Craig Chambers,David Ungar,Elgin Lee,An Efficient Implementation of SELF - a Dynamically-Typed Object-Oriented Language Based on Prototypes.
• John J. Shilling,Peter F. Sweeney,Three Steps to Views: Extending the Object-Oriented Paradigm.
• Trygve Reenskaug,Anna Lise Skaar,An Environment for Literate Smalltalk Programming.
• Patrick H. Dussud,TICLOS: An Implementation of CLOS for the Explorer Family.
• Marcel Schelvis,Incremental Distribution of Timestamp Packets: A New Approach to Distributed Garbage Collection.
• Naftaly H. Minsky,David Rozenshtein,Controllable Delegation: An Exercise in Law-Governed Systems.
• Ashwin V. Shah,James E. Rumbaugh,Jung H. Hamel,Renee E. Borsari,DSM: An Object-Relationship Modeling Language.
• Jacques Ferber,Computational Reflection in Class-Based Object-Oriented Languages.
• Max E. Jerrell,Function Minimization and Automatic Differentiation Using C++.
• Mary Beth Rosson,Eric Gold,Problem-Solution Mapping in Object-Oriented Design.
• John Alan McDonald,Object-Oriented Programming for Linear Algebra.
• Kent Beck,Ward Cunningham,A Laboratory for Teaching Object-Oriented Thinking.
• William H. Harrison,John J. Shilling,Peter F. Sweeney,Good News, Bad News: Experience Building a Software Development Environment Using the Object-Oriented Paradigm.
• Bjørn N. Freeman-Benson,A Module Mechanism for Constraints in Smalltalk.
• Bhavani M. Thuraisingham,Mandatory Security in Object-Oriented Database Systems.
• Yen-Ping Shan,An Event-Driven Model-View-Controller Framework for Smalltalk.
• Brian M. Barry,Prototyping a Real-Time Embedded System in Smalltalk.
• Thomas W. Page Jr.,Steven Berson,William C. Cheng,Richard R. Muntz,An Object-Oriented Modeling Environment.
• Jan van den Bos,Chris Laffra,PROCOL - A Parallel Object Language with Protocols.
• Sam S. Adams,Abdul K. Nabi,Neural Agents - A Frame of Mind.
• Hans Muller,John R. Rose,James Kempf,Tayloe Stansbury,The Use of Multimethods and Method Combination in a CLOS Based Window System Interface.
• Richard C. H. Connor,Alan Dearle,Ronald Morrison,Alfred L. Brown,An Object Addressing Mechanism for Statically Types Languages with Multiple Inheritance.
• Jay Fenton,Kent Beck,Playground: An Object-Oriented Simulation System With Agent Rules for Children of All Ages.
• Ole Lehrmann Madsen,Birger Møller-Pedersen,Virtual Classes: A Powerful Mechanism in Object-Oriented Programming.
• Peter S. Canning,William R. Cook,Walter L. Hill,Walter G. Olthoff,Interfaces for Strongly-Typed Object-Oriented Programming.
• Andreas Paepcke,PCLOS: A Critical Review.
• Patrick J. Ferrel,Robert F. Meyer,Vamp: The Aldus Application Framework.
• José Alves Marques,Paulo Guedes,Extending the Operating System to Support an Object-Oriented Environment.
• F. P. Block,N. C. Chan,An Extended Frame Language.
• Chris Tomlinson,Vineet Singh,Inheritance and Synchronization with Enabled Sets.
• Jay Almarode,Rule-Based Delegation for Prototypes.
• Nicolas Graube,Metaclass Compatibility.
• Jean-Pierre Briot,Pierre Cointe,Programming with Explicit Metaclasses in Smalltalk-80.
• Atsushi Ohori,Peter Buneman,Static Type Inference for Parametric Classes.
• Brian Foote,Ralph E. Johnson,Reflective Facilities in Smalltalk-80.
• John Maloney,Alan Borning,Bjørn N. Freeman-Benson,Constraint Technology fur User-Interface Construction in ThingLab II.
• William R. Cook,Jens Palsberg,A Denotational Semantics of Inheritance and its Correctness.
• Vincent F. Russo,Roy H. Campbell,Virtual Memory and Backing Storage Management in Multiprocessor Operating Systems Using Object-Oriented Design Techniques.
• R. Dixon,T. McKee,Paul Schweizer,M. Vaughan,A Fast Method Dispatcher for Compiled Languages with Multiple Inheritance.
• William R. Rosenblatt,Jack C. Wileden,Alexander L. Wolf,OROS: Toward a Type Model for Software Development Environments.
• Paul R. Wilson,Thomas G. Moher,Design of the Opportunistic Garbage Collector.

1988

• Won Kim,Nat Ballou,Hong-Tai Chou,Jorge F. Garza,Darrell Woelk,Jay Banerjee,Integrating an Object-Oriented Programming System with a Database System.
• Michael F. Kleyn,Paul C. Gingrich,GraphTrace - Understanding Object-Oriented Systems Using Concurrently Animated Views.
• Pedro A. Szekely,Brad A. Myers,A User Interface Toolkit Based on Graphical Objects and Constraints.
• Dave A. Thomas,Kent Johnson,Orwell - A Configuration Management System for Team Programming.
• John R. Rose,Fast Dispatch Mechanisms for Stock Hardware.
• Vincent F. Russo,Gary Johnston,Roy H. Campbell,Process Management and Exception Handling in Multiprocessor Operating Systems.
• Dan Ingalls,Scott Wallace,Yu-Ying Chow,Frank Ludolph,Ken Doyle,Fabrik: A Visual Programming Environment.
• Anders Björnerstedt,Stefan Britts,AVANCE: An Object Management System.
• Ralph E. Johnson,Justin O. Graver,Lawrence W. Zurawski,TS: An Optimizing Compiler for Smalltalk.
• Rebecca Wirfs-Brock,An Integrated Color Smalltalk-80 System.
• Kenneth S. Rubin,Patricia M. Jones,Christine M. Mitchell,Theodore C. Goldstein,A Smalltalk Implementation of an Intelligent Operator's Associate.
• Norihiko Yoshida,Kouji Hino,An Object-Oriented Framework of Pattern Recognition Systems.
• Takuo Watanabe,Akinori Yonezawa,Reflection in an Object-Oriented Concurrent Language.
• James E. Rumbaugh,Controlling Propagation of Operations Using Attributes on Relations.
• Bruno Alabiso,Transformation of Data Flow Analysis Models to Object-Oriented Design.
• Martha R. Szczur,Philip Miller,Transportable Applications Environment (TAE) Plus Experiences in "Object"-ively Modernizing a User Interface Environment.
• Edward H. Bensley,Thomas J. Brando,Myra Jean Prelle,An Execution Model for Distributed Object-Oriented Computation.
• Etsuya Shibayama,How To Invent Distributed Implementation Schemes of an Object-Based Concurrent Language: A Transformational Approach.
• David Beech,Intensional Concepts in an Object Database Model.
• C. A. Scaletti,Ralph E. Johnson,An Interactive Environment for Object-Oriented Music Composition and Sound Synthesis.
• Satoshi Matsuoka,Satoru Kawai,Using Tuple Space Communication in Distributed Object-Oriented Languages.
• Allen Wirfs-Brock,Brian Wilkerson,An Overview of Modular Smalltalk.
• Joshua Duhl,Craig Damon,A Performance Comparison of Object and Relational Databases Using the Sun Benchmark.
• André Weinand,Erich Gamma,Rudolph Marty,ET++ - An Object-Oriented Application Framework in C++.
• Mehmet Aksit,Anand R. Tripathi,Data Abstraction Mechanisms in SINA/ST.
• David Ungar,Frank Jackson,Tenuring Policies for Generation-Based Storage Reclamation.
• Karl J. Lieberherr,Ian M. Holland,Arthur J. Riel,Object-Oriented Programming: An Objective Sense of Style.
• Danny Epstein,Wilf R. LaLonde,A Smalltalk Window System Based on Constraints.
• Wilf R. LaLonde,Mark Van Gulik,Building a Backtracking Facility in Smalltalk Without Kernel Support.
• S. Sridhar,Configuring Stand-Alone Smalltalk-80 Applications.

1987

• Pierre Cointe,Metaclasses are First Class: the ObjVlisp Model.
• R. K. Kerr,D. B. Percival,Use of Object-Oriented Programming in a Time Series Analysis System.
• Yasuhiko Yokote,Mario Tokoro,Experience and Evolution of ConcurrentSmalltalk.
• Peter Wegner,Dimensions of Object-Based Language Design.
• Tim Andrews,Craig Harris,Combining Language and Database Advances in an Object-Oriented Development Environment.
• Robert L. Young,An Object-Oriented Framework for Interactive Data Graphics.
• Ed Seidewitz,Object-Oriented Programming in Smalltalk and ADA.
• James H. Alexander,Painless Panes for Smalltalk Windows.
• Ivar Jacobson,Object Oriented Development in an Industrial Environment.
• Thomas Merrow,Jane Laursen,A Pragmatic System for Shared Persistent Objects.
• D. Jason Penney,Jacob Stein,Class Modification in the GemStone Object-Oriented DBMS.
• Pattie Maes,Concepts and Experiments in Computational Reflection.
• Robert E. Filman,Retrofitting Objects.
• Lisa A. Call,David L. Cohrs,Barton P. Miller,CLAM - an Open System for Graphical User Interfaces.
• Andrew S. Grimshaw,Jane W.-S. Liu,Mentat: An Object-Oriented Macro Data Flow System.
• Paul L. McCullough,Transparent Forwarding: First Steps.
• John K. Bennett,The Design and Implementation of Distributed Smalltalk.
• Michael A. Caplinger,An Information System Based on Distributed Objects.
• Pieter S. van der Meulen,INSIST: Interactive Simulation in Smalltalk.
• Lars-Erik Thorelli,Modules and Type Checking in PL/LL.
• Steven H. Gutfreund,ManiplIcons in ThinkerToy.
• Renate Kempf,Marilyn Stelzner,Teaching Object-Oriented Programming with the KEE System.
• Eliot Miranda,BrouHaHa - A Portable Smalltalk Interpreter.
• Toby Bloom,Stanley B. Zdonik,Issues in the Design of Object-Oriented Database Programming Languages.
• Jim Diederich,Jack Milton,An Object-Oriented Design System Shell.
• Brad J. Cox,Kurt J. Schmucker,Producer: A Tool for Translating Smalltalk-80 to Objective-C.
• Patrick D. O'Brien,Daniel C. Halbert,Michael F. Kilian,The Trellis Programming Environment.
• Jane Laursen,Robert G. Atkinson,Opus: A Smalltalk Production System.
• Gail E. Kaiser,David Garlan,MELDing Data Flow and Object-Oriented Programming.
• Won Kim,Jay Banerjee,Hong-Tai Chou,Jorge F. Garza,Darrell Woelk,Composite Object Support in an Object-Oriented Database System.
• Brian M. Barry,John R. Altoft,Dave A. Thomas,Mike Wilson,Using Objects To Design and Build Radar ESM Systems.
• Naftaly H. Minsky,David Rozenshtein,A Law-Based Approach to Object-Oriented Programming.
• Jean Bézivin,Some Experiments In Object-Oriented Simulation.
• Karl Freburger,RAPID: Prototyping Control Panel Interfaces.
• Mark Grossman,Raimund K. Ege,Logical Composition of Object-Oriented Interfaces.
• David Ungar,Randall B. Smith,Self: The Power of Simplicity.
• Karen E. Smith,Stanley B. Zdonik,Intermedia: A Case Study of the Differences Between Relational and Object-Oriented Database Systems.
• Steven Lucco,Parallel Programming in a Virtual Object Space.
• James Kempf,Warren Harris,Roy D'Souza,Alan Snyder,Experience with CommonLoops.
• Lynn Andrea Stein,Delegation Is Inheritance.
• John Hogg,Steven Weiser,OTM: Applying Objects to Tasks.
• James E. Rumbaugh,Relations as Semantic Constructs in an Object-Oriented Language.
• Alan Borning,Robert Duisberg,Bjørn N. Freeman-Benson,Axel Kramer,Michael Woolf,Constraint Hierarchies.
• Oscar Nierstrasz,Active Objects in Hybrid.

1986

• Yutaka Ishikawa,Mario Tokoro,A Concurrent Object-Oriented Knowledge Representation Language Orient84/K: Its Features and Implementation.
• Alan Snyder,Encapsulation and Inheritance in Object-Oriented Programming Languages.
• Craig Schaffert,Topher Cooper,Bruce Bullis,Mike Killian,Carrie Wilpolt,An Introduction to Trellis/Owl.
• Douglas Wiebe,A Distributed Repository for Immutable Persistent Objects.
• David B. Anderson,Experience with Flamingo: A Distributed, Object-Oriented User Interface System.
• Dominique Decouchant,Design of a Distributed Object Manager for the Smalltalk-80 System.
• David A. Moon,Object-Oriented Programming with Flavors.
• David A. McAllester,Ramin Zabih,Boolean Classes.
• Juanita J. Ewing,An Object-Oriented Operating System Interface.
• Geoffrey A. Pascoe,Encapsulators: A New Software Paradigm in Smalltalk-80.
• Robert G. Atkinson,Hurricane: An Optimizing Compiler for Smalltalk.
• Sanjay Mittal,Daniel G. Bobrow,Kenneth M. Kahn,Virtual Copies - At the Boundary Between Classes and Instances.
• David Sandberg,An Alternative to Subclassing.
• Yasuhiko Yokote,Mario Tokoro,The Design and Implementation of ConcurrentSmalltalk.
• Norman K. Meyrowitz,Intermedia: The Architecture and Construction of an Object-Oriented Hypermedia System and Applications Framework.
• Kurt W. Piersol,Object Oriented Spreadsheets: The Analytic Spreadsheet Package.
• Reid G. Smith,Rick Dinitz,Paul Barth,Impulse-86: A Substrate for Object-Oriented Interface Design.
• David M. Lewis,David R. Galloway,Robert J. Francis,Brian W. Thomson,Swamp: A Fast Processor for Smalltalk-80.
• Ivar Jacobson,Language Support for Changeable Large Real Time Systems.
• Jonathan Jacky,Ira Kalet,An Object-Oriented Approach to a Large Scientific Application.
• Thomas A. Cargill,Pi: A Case Study in Object-Oriented Programming.
• Partha Dasgupta,A Probe-Based Monitoring Scheme for an Object-Oriented Distributed Operating System.
• Michael B. Jones,Richard F. Rashid,Mach and Matchmaker: Kernel and Language Support for Object-Oriented Distributed Systems.
• Koichi Fukunaga,Shin'ichi Hirose,An Experience with a Prolog-based Object-Oriented Language.
• A. Dain Samples,David Ungar,Paul N. Hilfinger,SOAR: Smalltalk Without Bytecodes.
• David Maier,Jacob Stein,Allen Otis,Alan Purdy,Development of an Object-Oriented DBMS.
• L. Nancy Garrett,Karen E. Smith,Building a Timeline Editor from Prefab Parts: The Architecture of an Object-Oriented Application.
• Bertrand Meyer,Genericity versus Inheritance.
• Akinori Yonezawa,Jean-Pierre Briot,Etsuya Shibayama,Object-Oriented Concurrent Programming in ABCL/1.
• Wilf R. LaLonde,Dave A. Thomas,John R. Pugh,An Exemplar Based Smalltalk.
• Kevin J. Lang,Barak A. Pearlmutter,Oaklisp: an Object-Oriented Scheme with First Class Types.
• Walter G. Olthoff,Augmentation of Object-Oriented Programming by Concepts of Abstract Data Type Theory: The ModPascal Experience.
• Ted Kaehler,Virtual Memory on a Narrow Machine for an Object-Oriented Language.
• S. Kamal Abdali,Guy W. Cherry,Neil Soiffer,A Smalltalk System for Algebraic Manipulation.
• Ward Cunningham,Kent Beck,A Diagram for Object-Oriented Programs.
• Kenneth M. Kahn,Eric Dean Tribble,Mark S. Miller,Daniel G. Bobrow,Objects in Concurrent Logic Programming Languages.
• Patrick J. Caudill,Allen Wirfs-Brock,A Third Generation Smalltalk-80 Implementation.
• K. S. Bhaskar,J. K. Pecol,James L. Beug,Virtual Instruments: Object-Oriented Program Synthesis.
• Mark B. Ballard,David Maier,Allen Wirfs-Brock,Quicktalk: A Smalltalk-80 Dialect for Defining Primitive Methods.
• Michael S. Miller,Howard Cunningham,Chan Lee,Steven R. Vegdahl,The Application Accelerator Illustration System.
• Henry Lieberman,Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems.
• Giorgio Bruno,Alessandro Balsamo,Petri Net-Based Object-Oriented Modeling of Distributed Systems.
• Daniel G. Bobrow,Kenneth M. Kahn,Gregor Kiczales,Larry Masinter,Mark Stefik,Frank Zdybel,CommonLoops: Merging Lisp and Object-Oriented Programming.
• Andrea H. Skarra,Stanley B. Zdonik,The Management of Changing Types in an Object-Oriented Database.
• Ralph E. Johnson,Type-Checking Smalltalk.
• Jeffrey Bonar,Robert K. Cunningham,Jamie Schultz,An Object-Oriented Architecture for Intelligent Tutoring Systems.
• Andrew P. Black,Norman C. Hutchinson,Eric Jul,Henry M. Levy,Object Structure in the Emerald System.
• Steven R. Vegdahl,Moving Structures between Smalltalk Images.
• Setrag Khoshafian,George P. Copeland,Object Identity.