Customization: Optimizing Compiler Technology for SELF, A Dynamically-Typed Object-Oriented Programming Language. - Craig Chambers; David M. Ungar (PLDI, 1989)

A retrospective on: "customization: optimizing compiler technology for self, a dynamically-typed object-oriented programming language" (with retrospective) - Craig Chambers; David M. Ungar (Best of PLDI, 1989)

Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches. - Urs Hölzle; Craig Chambers; David M. Ungar (ECOOP, 1991)

Making Pure Object-Oriented Languages Practical. - Craig Chambers; David M. Ungar (OOPSLA, 1991)

Iterative Type Analysis and Extended Message Splitting: Optimizing Dynamically-Typed Object-Oriented Programs. - Craig Chambers; David M. Ungar (LISP Symb. Comput., 1991)

Parents are Shared Parts of Objects: Inheritance and Encapsulation in SELF. - Craig Chambers; David M. Ungar; Bay-Wei Chang; Urs Hölzle (LISP Symb. Comput., 1991)

An Efficient Implementation of SELF, a Dynamically-Typed Object-Oriented Language Based on Prototypes. - Craig Chambers; David M. Ungar; Elgin Lee (LISP Symb. Comput., 1991)

Organizing Programs Without Classes. - Craig Chambers; David M. Ungar; Bay-Wei Chang; Urs Hölzle (LISP Symb. Comput., 1991)

Object-Oriented Multi-Methods in Cecil. - Craig Chambers (ECOOP, 1992)

Debugging Optimized Code with Dynamic Deoptimization. - Urs Hölzle; Craig Chambers; David M. Ungar (PLDI, 1992)

Object, Message, and Performance: How They Coexist in Self. - David M. Ungar; Randall B. Smith; Craig Chambers; Urs Hölzle (Computer, 1992)

Efficient implementation of object-oriented programming lanaguages (abstract). - Craig Chambers; David M. Ungar (OOPSLA Addendum, 1992)

The Design and Implementation of the SELF Compiler, an Optimizing Compilet for Object-Oriented Programming Languages - Craig Chambers (1992)

Predicate Classes. - Craig Chambers (ECOOP, 1993)

Towards Better Inlining Decisions Using Inlining Trials. - Jeffrey Dean; Craig Chambers (LISP and Functional Programming, 1994)

Typechecking and Modules for Multi-Methods. - Craig Chambers; Gary T. Leavens (OOPSLA, 1994)

Identifying Profitable Specialization in Object-Oriented Languages. - Jeffrey Dean; Craig Chambers; David Grove (PEPM, 1994)

Optimization of Object-Oriented Programs Using Static Class Hierarchy Analysis. - Jeffrey Dean; David Grove; Craig Chambers (ECOOP, 1995)

A Framework for Selective Recompilation in the Presence of Complex Intermodule Dependencies. - Craig Chambers; Jeffrey Dean; David Grove (ICSE, 1995)

Profile-Guided Receiver Class Prediction. - David Grove; Jeffrey Dean; Charles Garrett; Craig Chambers (OOPSLA, 1995)

Selective Specialization for Object-Oriented Languages. - Jeffrey Dean; Craig Chambers; David Grove (PLDI, 1995)

Extensibility, Safety and Performance in the SPIN Operating System. - Brian N. Bershad; Stefan Savage; Przemyslaw Pardyak; Emin Gün Sirer; Marc E. Fiuczynski; David Becker; Craig Chambers; Susan J. Eggers (SOSP, 1995)

SPIN - An Extensible Microkernel for Application-specific Operating System Services. - Brian N. Bershad; Craig Chambers; Susan J. Eggers; Chris Maeda; Dylan McNamee; Przemyslaw Pardyak; Stefan Savage; Emin Gün Sirer (ACM SIGOPS Oper. Syst. Rev., 1995)

Typechecking and Modules for Multimethods. - Craig Chambers; Gary T. Leavens (ACM Trans. Program. Lang. Syst., 1995)

Synergies Between Object-Oriented Programming Language Design and Implementation Research. - Craig Chambers (ISOTAS, 1996)

Vortex: An Optimizing Compiler for Object-Oriented Languages. - Jeffrey Dean; Greg DeFouw; David Grove; Vassily Litvinov; Craig Chambers (OOPSLA, 1996)

Fast, Effective Dynamic Compilation. - Joel Auslander; Matthai Philipose; Craig Chambers; Susan J. Eggers; Brian N. Bershad (PLDI, 1996)

Towards Reusable, Extensible Components. - Craig Chambers (ACM Comput. Surv., 1996)

Call Graph Construction in Object-Oriented Languages. - David Grove; Greg DeFouw; Jeffrey Dean; Craig Chambers (OOPSLA, 1997)

Annotation-Directed Run-Time Specialization in C. - Brian Grant; Markus Mock; Matthai Philipose; Craig Chambers; Susan J. Eggers (PEPM, 1997)

Predicate Dispatching: A Unified Theory of Dispatch. - Michael D. Ernst; Craig S. Kaplan; Craig Chambers (ECOOP, 1998)

Fast Interprocedural Class Analysis. - Greg DeFouw; David Grove; Craig Chambers (POPL, 1998)

Dependence Analysis for Java. - Craig Chambers; Igor Pechtchanski; Vivek Sarkar; Mauricio J. Serrano; Harini Srinivasan (LCPC, 1999)

Efficient Multiple and Predicated Dispatching. - Craig Chambers; Weimin Chen 004 (OOPSLA, 1999)

An Evaluation of Staged Run-Time Optimizations in DyC. - Brian Grant; Matthai Philipose; Markus Mock; Craig Chambers; Susan J. Eggers (PLDI, 1999)

An evaluation of staged run-time optimizations in DyC (with retrospective) - Brian Grant; Matthai Philipose; Markus Mock; Craig Chambers; Susan J. Eggers (Best of PLDI, 1999)

Static Analyses for Eliminating Unnecessary Synchronization from Java Programs. - Jonathan Aldrich; Craig Chambers; Emin Gün Sirer; Susan J. Eggers (SAS, 1999)

DyC (Panel Session). - Ron Cytron; Craig Chambers (Dynamo, 2000)

Calpa: a tool for automating selective dynamic compilation. - Markus Mock; Craig Chambers; Susan J. Eggers (MICRO, 2000)

MultiJava: modular open classes and symmetric multiple dispatch for Java. - Curtis Clifton; Gary T. Leavens; Craig Chambers; Todd D. Millstein (OOPSLA, 2000)

A Debate on Language and Tool Support for Design Patterns. - Craig Chambers; Bill Harrison; John M. Vlissides (POPL, 2000)

DyC: an expressive annotation-directed dynamic compiler for C. - Brian Grant; Markus Mock; Matthai Philipose; Craig Chambers; Susan J. Eggers (Theor. Comput. Sci., 2000)

The benefits and costs of DyC's run-time optimizations. - Brian Grant; Markus Mock; Matthai Philipose; Craig Chambers; Susan J. Eggers (ACM Trans. Program. Lang. Syst., 2000)

Dynamic points-to sets: a comparison with static analyses and potential applications in program understanding and optimization. - Markus Mock; Manuvir Das; Craig Chambers; Susan J. Eggers (PASTE, 2001)

A framework for call graph construction algorithms. - David Grove; Craig Chambers (ACM Trans. Program. Lang. Syst., 2001)

Architectural Reasoning in ArchJava. - Jonathan Aldrich; Craig Chambers; David Notkin (ECOOP, 2002)

ArchJava: connecting software architecture to implementation. - Jonathan Aldrich; Craig Chambers; David Notkin (ICSE, 2002)

Alias annotations for program understanding. - Jonathan Aldrich; Valentin Kostadinov; Craig Chambers (OOPSLA, 2002)

Staged compilation. - Craig Chambers (PEPM, 2002)

Composing dataflow analyses and transformations. - Sorin Lerner; David Grove; Craig Chambers (POPL, 2002)

Towards automatic construction of staged compilers. - Matthai Philipose; Craig Chambers; Susan J. Eggers (POPL, 2002)

Improving program slicing with dynamic points-to data. - Markus Mock; Darren C. Atkinson; Craig Chambers; Susan J. Eggers (SIGSOFT FSE, 2002)

Architecture-centric programming for adaptive systems. - Jonathan Aldrich; Vibha Sazawal; Craig Chambers; David Notkin (WOSS, 2002)

Modular Statically Typed Multimethods. - Todd D. Millstein; Craig Chambers (Inf. Comput., 2002)

Language Support for Connector Abstractions. - Jonathan Aldrich; Vibha Sazawal; Craig Chambers; David Notkin (ECOOP, 2003)

HydroJ: object-oriented pattern matching for evolvable distributed systems. - Keunwoo Lee; Anthony LaMarca; Craig Chambers (OOPSLA, 2003)

Relaxed MultiJava: balancing extensibility and modular typechecking. - Todd D. Millstein; Mark Reay; Craig Chambers (OOPSLA, 2003)

Automatically proving the correctness of compiler optimizations. - Sorin Lerner; Todd D. Millstein; Craig Chambers (PLDI, 2003)

Comprehensive synchronization elimination for Java. - Jonathan Aldrich; Emin Gün Sirer; Craig Chambers; Susan J. Eggers (Sci. Comput. Program., 2003)

Ownership Domains: Separating Aliasing Policy from Mechanism. - Jonathan Aldrich; Craig Chambers (ECOOP, 2004)

Cobalt: A Language for Writing Provably-Sound Compiler Optimizations. - Sorin Lerner; Todd D. Millstein; Craig Chambers (COCV@ETAPS, 2004)

Modular typechecking for hierarchically extensible datatypes and functions. - Todd D. Millstein; Colin Bleckner; Craig Chambers (ACM Trans. Program. Lang. Syst., 2004)

Automated soundness proofs for dataflow analyses and transformations via local rules. - Sorin Lerner; Todd D. Millstein; Erika Rice; Craig Chambers (POPL, 2005)

Program Slicing with Dynamic Points-To Sets. - Markus Mock; Darren C. Atkinson; Craig Chambers; Susan J. Eggers (IEEE Trans. Software Eng., 2005)

Parameterized Modules for Classes and Extensible Functions. - Keunwoo Lee; Craig Chambers (ECOOP, 2006)

Seminal: searching for ML type-error messages. - Benjamin S. Lerner; Dan Grossman; Craig Chambers (ML, 2006)

MultiJava: Design rationale, compiler implementation, and applications. - Curtis Clifton; Todd D. Millstein; Gary T. Leavens; Craig Chambers (ACM Trans. Program. Lang. Syst., 2006)

Searching for type-error messages. - Benjamin S. Lerner; Matthew Flower; Dan Grossman; Craig Chambers (PLDI, 2007)

Automatic inference of optimizer flow functions from semantic meanings. - Erika Rice Scherpelz; Sorin Lerner; Craig Chambers (PLDI, 2007)

A theory of platform-dependent low-level software. - Marius Nita; Dan Grossman; Craig Chambers (POPL, 2008)

FlumeJava: easy, efficient data-parallel pipelines. - Craig Chambers; Ashish Raniwala; Frances Perry; Stephen Adams 001; Robert R. Henry 001; Robert Bradshaw; Nathan Weizenbaum (PLDI, 2010)

Expressiveness, Simplicity, and Users. - Craig Chambers (ECOOP, 2011)

Subphonemic Detail in Lexical Perception and Production: The Case of Canadian Raising. - Juli Cebrian; Craig Chambers (ICPhS, 2011)

The Dataflow Model: A Practical Approach to Balancing Correctness, Latency, and Cost in Massive-Scale, Unbounded, Out-of-Order Data Processing. - Tyler Akidau; Robert Bradshaw; Craig Chambers; Slava Chernyak; Rafael Fernández-Moctezuma; Reuven Lax; Sam McVeety; Daniel Mills; Frances Perry; Eric Schmidt 001; Sam Whittle (Proc. VLDB Endow., 2015)