Last update:
Wed Nov 30 17:56:04 MST 2011
William D. Clinger How to Read Floating Point Numbers
Accurately . . . . . . . . . . . . . . . 92--101
Guy L. Steele, Jr. and
Jon L. White How to Print Floating-Point Numbers
Accurately . . . . . . . . . . . . . . . 112--126
Emin Gün Sirer and
Brian N. Bershad Using Production Grammars in Software
Testing . . . . . . . . . . . . . . . . 1--13
Lloyd H. Nakatani and
Mark A. Ardis and
Robert G. Olsen and
Paul M. Pontrelli Jargons for Domain Engineering . . . . . 15--24
James Reichwein and
Gregg Rothermel and
Margaret Burnett Slicing Spreadsheets: An Integrated
Methodology for Spreadsheet Testing and
Debugging . . . . . . . . . . . . . . . 25--38
Samuel Z. Guyer and
Calvin Lin An Annotation Language for Optimizing
Software Libraries . . . . . . . . . . . 39--52
Vijay Menon and
Keshav Pingali A Case for Source-Level Transformations
in MATLAB . . . . . . . . . . . . . . . 53--65
Dale E. Parson Using Java Reflection to Automate
Extension Language Parsing . . . . . . . 67--80
Tim Sheard and
Zine-el-abidine Benaissa and
Emir Pasalic DSL Implementation Using Staging and
Monads . . . . . . . . . . . . . . . . . 81--94
John Peterson and
Greg Hager Monadic Robotics . . . . . . . . . . . . 95--108
Daan Leijen and
Erik Meijer Domain-Specific Embedded Compilers . . . 109--122
James Jennings and
Eric Beuscher Verischemelog: Verilog Embedded in
Scheme . . . . . . . . . . . . . . . . . 123--134
Mary Fernández and
Dan Suciu and
Igor Tatarinov Declarative Specification of
Data-Intensive Web Sites . . . . . . . . 135--148
Du Li and
Richard R. Muntz A Collaboration Specification Language 149--162
Dan Bonachea and
Kathleen Fisher and
Anne Rogers and
Frederick Smith Hancock: A Language for Processing Very
Large-Scale Data . . . . . . . . . . . . 163--176
Barbara G. Ryder Conference Corner: PLDI '99: Programming
Language Design and Implementation
(Report) . . . . . . . . . . . . . . . . 9--9
Barbara Ryder PLDI '99: Programming language design
and implementation . . . . . . . . . . . 9--10
Chis Clark Practical Parsing Patterns: Uniform
Abstract Syntax Trees . . . . . . . . . 11--16
Chris Clark Uniform abstract syntax trees . . . . . 11--16
Paul Frenger Forth: The Ultimate RISC: A
Zero-Instruction Computer . . . . . . . 17--23
Paul Frenger The Ultimate RISC: A zero-instruction
computer . . . . . . . . . . . . . . . . 17--24
Kirk Reinholtz Java will be faster than C++ . . . . . . 25--28
Kirk Reinholtz Technical Correspondence: Java will be
faster than C++ . . . . . . . . . . . . 25--28
Matthew S. Davis An Object Oriented Approach to
Constructing Recursive Descent Parsers 29--35
Dragan Milicev and
Zoran Jovanovic Sources of parallelism in software
pipelining loops with conditional
branches . . . . . . . . . . . . . . . . 36--45
Dragan Milicev and
Zoran Jovanovic Sources in Software Pipelining Loops
with Conditions Branches . . . . . . . . 36--45
Volker Simonis Adapters and Binders --- Overcoming
Problems in the Design and
Implementation of the C++-STL . . . . . 46--53
Gaoyan Xie and
Yongsen Xu and
Yu Li and
Qian Li Codebugger: a software tool for
cooperative debugging . . . . . . . . . 54--60
Bing Swen Object-Oriented Programming with
Induction . . . . . . . . . . . . . . . 61--67
Anonymous Important Information for ACM SIGPLAN
Notices Authors . . . . . . . . . . . . 1--1
Mary Lou Soffa Executive Committee News: 1999 SIGPLAN
Awards . . . . . . . . . . . . . . . . . 2--3
Seth Bergmann Conference Corner: Calendar . . . . . . 4--15
Enrico Pontelli and
Vitor Santos Costa Conference Corner: Conference Report:
PADL '00: Workshop on Practical Aspects
of Declarative Languages . . . . . . . . 16--17
Peter Chalk Conference Corner: Conference Report:
JICC4: Java in the Computing Curricula 18--19
Peter Chalk JICC4: Java in the computing curricula 18--19
Anonymous Call for Papers: 2000 International
Symposium on Memory Management (ISMM),
Minneapolis, Minnesota, October 15--16,
2000 . . . . . . . . . . . . . . . . . . 20--20
Brent W. Benson, Jr. Java Reflections: Servlets: Web-Based
Applications You Can Live With . . . . . 21--24
Brent W. Benson, Jr. Web-based applications you can live with 21--24
Paul Frenger Forth Report: Learning Forth with
Modular Forth . . . . . . . . . . . . . 25--30
Paul Frenger Learning Forth with Modular Forth . . . 25--30
Tim Bergin History of Programming Languages and
Software Engineering: A Web-Based Tool 31--31
David Padua and
Ron Cytron Compilers and Interpreters Archive . . . 32--32
A. Michael Bergmann Information for Authors . . . . . . . . 33--33
Yu Li and
Gaoyan Xie and
Yongsen Xu and
Yi Yang The Security Problem of Nested Classes 34--38
Li Yu and
Xie Gaoyan and
Xu Yongsen and
Yang Yi The security problem of nested classes 34--38
Jan Heering and
Paul Klint Semantics of Programming Languages: A
Tool-Oriented Approach . . . . . . . . . 39--48
Mayur Naik and
Rajeev Kumar Efficient Message Dispatch in
Object-Oriented Systems . . . . . . . . 49--58
Peter Kokol and
Vili Podgorelec Ranking the Complexity of NIAM
Conceptual Schemas by Alpha Metric . . . 59--64
Tao Li and
XiaoJie Liu An Intelligent Neural Network
Programming System (NNPS) . . . . . . . 65--72
Norman Ramsey and
Kevin Scott The 1999 ICFP Programming Contest . . . 73--83
A. Michael Berman Letter from the Editor; Welcome ever
smiles \slash And farewell goes out
sighing . . . . . . . . . . . . . . . . 1--1
A. Michael Berman Important Information for ACM SIGPLAN
Notices Authors . . . . . . . . . . . . 2--2
Seth Bergmann Conference Corner: Calendar . . . . . . 3--16
Anonymous Call for Papers: The 28th Annual
ACM-SIGACT Symposium Principles of
Programming Languages, London, January
17--19, 2001 (POPL'01) . . . . . . . . . 17--17
Chris Clark Newlines and lexer states . . . . . . . 18--24
Chris Clark Practical Parsing Patterns: Newlines and
Lexer States . . . . . . . . . . . . . . 18--24
Cindy Norris Information for Authors . . . . . . . . 25--25
Kim B. Bruce Curriculum 2001 Draft Found Lacking in
Programming Languages . . . . . . . . . 26--28
Anonymous Proposed knowledge units for programming
languages for Curriculum 2001 . . . . . 29--43
Programming Language Knowledge Focus Group Proposed Knowledge Units for Programming
Languages for Curriculum 2001 . . . . . 29--43
Geetha Manjunath and
Venkatesh Krishnan A \em Small Hybrid JIT for Embedded
Systems . . . . . . . . . . . . . . . . 44--50
Alexander Sakharov A Hybrid State Machine Notation for
Component Specification . . . . . . . . 51--56
Vasanth Bala and
Evelyn Duesterwald and
Sanjeev Banerjia Dynamo: a transparent dynamic
optimization system . . . . . . . . . . 1--12
Micha\l Cierniak and
Guei-Yuan Lueh and
James M. Stichnoth Practicing JUDO: Java under dynamic
optimizations . . . . . . . . . . . . . 13--26
Steven Lucco Split-stream dictionary program
compression . . . . . . . . . . . . . . 27--34
Manuvir Das Unification-based pointer analysis with
directional assignments . . . . . . . . 35--46
Atanas Rountev and
Satish Chandra Off-line variable substitution for
scaling points-to analysis . . . . . . . 47--56
Ben-Chung Cheng and
Wen-mei W. Hwu Modular interprocedural pointer analysis
using access paths: design,
implementation, and evaluation . . . . . 57--69
Zhichen Xu and
Barton P. Miller and
Thomas Reps Safety checking of machine code . . . . 70--82
George C. Necula Translation validation for an optimizing
compiler . . . . . . . . . . . . . . . . 83--94
Christopher Colby and
Peter Lee and
George C. Necula and
Fred Blau and
Mark Plesko and
Kenneth Cline A certifying compiler for Java . . . . . 95--107
Mark Stephenson and
Jonathan Babb and
Saman Amarasinghe Bidwidth analysis with application to
silicon compilation . . . . . . . . . . 108--120
Kent Wilken and
Jack Liu and
Mark Heffernan Optimal instruction scheduling using
integer programming . . . . . . . . . . 121--133
Javier Zalamea and
Josep Llosa and
Eduard Ayguadé and
Mateo Valero Improved spill code generation for
software pipelined loops . . . . . . . . 134--144
Samuel Larsen and
Saman Amarasinghe Exploiting superword level parallelism
with multimedia instruction sets . . . . 145--156
Yuan Lin and
David Padua Compiler analysis of irregular memory
accesses . . . . . . . . . . . . . . . . 157--168
Qing Yi and
Vikram Adve and
Ken Kennedy Transforming loops to recursion for
multi-level memory hierarchies . . . . . 169--181
Radu Rugina and
Martin Rinard Symbolic bounds analysis of pointers,
array indices, and accessed memory
regions . . . . . . . . . . . . . . . . 182--195
Vugranam C. Sreedhar and
Michael Burke and
Jong-Deok Choi A framework for interprocedural
optimization in the presence of dynamic
class loading . . . . . . . . . . . . . 196--207
Erik Ruf Effective synchronization removal for
Java . . . . . . . . . . . . . . . . . . 208--218
Cormac Flanagan and
Stephen N. Freund Type-based race detection for Java . . . 219--232
G. Ramalingam On loops, dominators, and dominance
frontier . . . . . . . . . . . . . . . . 233--241
Zhanyong Wan and
Paul Hudak Functional reactive programming from
first principles . . . . . . . . . . . . 242--252
Manuel Fähndrich and
Jakob Rehof and
Manuvir Das Scalable context-sensitive flow analysis
using instantiation constraints . . . . 253--263
Dante J. Cannarozzi and
Michael P. Plezbert and
Ron K. Cytron Contaminated garbage collection . . . . 264--273
Tamar Domani and
Elliot K. Kolodner and
Erez Petrank A generational on-the-fly garbage
collector for Java . . . . . . . . . . . 274--284
Norman Ramsey and
Simon Peyton Jones A single intermediate language that
supports multiple implementations of
exceptions . . . . . . . . . . . . . . . 285--298
Bob Boothe Efficient algorithms for bidirectional
debugging . . . . . . . . . . . . . . . 299--310
Allan Heydon and
Roy Levin and
Yuan Yu Caching function calls using precise
dependencies . . . . . . . . . . . . . . 311--320
Rastislav Bodík and
Rajiv Gupta and
Vivek Sarkar ABCD: eliminating array bounds checks on
demand . . . . . . . . . . . . . . . . . 321--333
Sanjay Ghemawat and
Keith H. Randall and
Daniel J. Scales Field analysis: getting useful and
low-cost interprocedural information . . 334--344
Julian Dolby and
Andrew Chien An automatic object inlining
optimization and its evaluation . . . . 345--357
Ron Cytron Letter from the Chair . . . . . . . . . 1--1
Seth Bergmann Conference Corner: Calendar . . . . . . 2--14
Chris Clark Practical Parsing Patterns: Off-and-On
Tokens . . . . . . . . . . . . . . . . . 15--20
Chris Clark Off-and-on tokens . . . . . . . . . . . 15--20
Paul Frenger Forth Report: The GOTO Machine . . . . . 21--24
Paul Frenger GOTO machine . . . . . . . . . . . . . . 21--24
Jan Fenwick and
Cindy Norris Information for Authors . . . . . . . . 25--25
Arie van Deursen and
Paul Klint and
Joost Visser Domain-Specific Languages: An Annotated
Bibliography . . . . . . . . . . . . . . 26--36
Y. N. Srikant and
D. V. Ravindra Effective Parametrization of
Architectural Registers for Register
Allocation Algorithms . . . . . . . . . 37--46
Sibylle Schupp Lazy Lists in C++ . . . . . . . . . . . 47--54
Michael D. Smith Overcoming the challenges to
feedback-directed optimization (Keynote
Talk) . . . . . . . . . . . . . . . . . 1--11
Dawson R. Engler and
Wilson C. Hsieh Derive: a tool that automatically
reverse-engineers instruction encodings 12--22
Erik Johansson and
Sven-olof Nyström Profile-Guided Optimization Across
Process Boundaries . . . . . . . . . . . 23--31
Michael J. Voss and
Rudolf Eigenmann A Framework for Remote Dynamic Program
Optimization . . . . . . . . . . . . . . 32--40
David Ung and
Cristina Cifuentes Machine-Adaptable Dynamic Binary
Translation . . . . . . . . . . . . . . 41--51
Matthew Arnold and
Stephen Fink and
Vivek Sarkar and
Peter F. Sweeney A Comparative Study of Static and
Profile-Based Heuristics for Inlining 52--64
Eduard Mehofer and
Bernhard Scholz Probabilistic Data Flow System with
Two-Edge Profiling . . . . . . . . . . . 65--72
Craig Chambers DyC . . . . . . . . . . . . . . . . . . 73--74
Craig Chambers DyC (Panel Session) . . . . . . . . . . 73--74
Vasanth Bala Dynamo: A Transparent, Dynamic, Native
Binary Optimizer . . . . . . . . . . . . 75--75
Ron Cytron and
Vasanth Bala Dynamo (Panel Session): a transparent,
dynamic, native binary optimizer . . . . 75--75
Ron Cytron and
Renaud Marlet Tempo, a program specializer for C
(Panel Session) . . . . . . . . . . . . 76--77
Renaud Marlet Tempo, a program specializer for C . . . 76--77
Ron Cytron and
Vivek Sarkar Dynamic compilation in Jalapeño (Panel
Session) . . . . . . . . . . . . . . . . 78--78
Vivek Sarkar Dynamic Compilation in Jalapeño . . . . . 78--78
Yoo C. Chung and
Michael J. Voss Summary of the Dynamo '00 Panel
Discussion . . . . . . . . . . . . . . . 79--81
Ron Cytron and
Yoo C. Chung and
Michael J. Voss Summary of the Dynamo '00 panel
discussion (Panel Session) . . . . . . . 79--81
Ron Cytron Executive Committee News: SIGPLAN Awards 1--2
Seth Bergmann Conference Corner: Calendar . . . . . . 3--14
Paul Frenger Forth and the FreeBSD bootloader . . . . 15--17
Paul Frenger Forth Report: Forth and the FreeBSD
Bootloader . . . . . . . . . . . . . . . 15--17
Jan Fenwick and
Cindy Norris Information for Authors . . . . . . . . 18--18
Jan Fenwick and
Cindy Norris Information for Past Authors . . . . . . 19--19
Ulisses Fereira uu for Programming Languages . . . . . . 20--30
Ulisses Ferreira uu for programming languages . . . . . . 20--30
Matjaz B. Juric and
Ivan Rozman and
Simon Nash Java 2 Distributed Object Middleware
Performance Analysis and Optimization 31--40
Limsoon Wong The functional guts of the Kleisli query
system . . . . . . . . . . . . . . . . . 1--10
Haruo Hosoya and
Jérôme Vouillon and
Benjamin C. Pierce Regular expression types for XML . . . . 11--22
Christian Queinnec The influence of browsers on evaluators
or, continuations to program Web servers 23--33
Christian Skalka and
Scott Smith Static enforcement of security with
types . . . . . . . . . . . . . . . . . 34--45
François Pottier and
Sylvain Conchon Information flow inference for free . . 46--57
Stephanie Weirich Type-safe cast: (functional pearl) . . . 58--67
Karl Crary Typed compilation of inclusive subtyping 68--81
Valery Trifonov and
Bratin Saha and
Zhong Shao Fully reflexive intensional type
analysis . . . . . . . . . . . . . . . . 82--93
Manuel M. T. Chakravarty and
Gabriele Keller More types for nested data parallel
programming . . . . . . . . . . . . . . 94--105
Meurig Sage FranTk --- a declarative GUI language
for Haskell . . . . . . . . . . . . . . 106--117
Brian McNamara and
Yannis Smaragdakis Functional programming in C++ . . . . . 118--129
Robert Harper and
Benjamin C. Pierce Advanced module systems (invited talk):
a guide for the perplexed . . . . . . . 130--130
Chris Okasaki Breadth-first numbering: lessons from a
small exercise in algorithm design . . . 131--136
Isao Sasano and
Zhenjiang Hu and
Masato Takeichi and
Mizuhito Ogawa Make it practical: a generic linear-time
algorithm for solving maximum-weightsum
problems . . . . . . . . . . . . . . . . 137--149
Karl-Filip Faxén Cheap eagerness: speculative evaluation
in a lazy functional language . . . . . 150--161
Clem Baker-Finch and
David J. King and
Phil Trinder An operational semantics for parallel
lazy evaluation . . . . . . . . . . . . 162--173
Levent Erkök and
John Launchbury Recursive monadic bindings . . . . . . . 174--185
Ralf Hinze Deriving backtracking monad transformers 186--197
Rowan Davies and
Frank Pfenning Intersection types and computational
effects . . . . . . . . . . . . . . . . 198--208
Daniel Damian and
Olivier Danvy Syntactic accidents in program analysis:
on the impact of the CPS transformation 209--220
Vladimir Gapeyev and
Michael Y. Levin and
Benjamin C. Pierce Recursive subtyping revealed:
(functional pearl) . . . . . . . . . . . 221--231
Pierre-Louis Curien and
Hugo Herbelin The duality of computation . . . . . . . 233--243
Carl Seger Combining functional programming and
hardware verification (invited talk) . . 244--244
Manuel Serrano and
Hans-J. Boehm Understanding memory allocation of
scheme programs . . . . . . . . . . . . 245--256
A. M. Cheadle and
A. J. Field and
S. Marlow and
S. L. Peyton Jones and
R. L. While Non-stop Haskell . . . . . . . . . . . . 257--267
Koen Claessen and
John Hughes QuickCheck: a lightweight tool for
random testing of Haskell programs . . . 268--279
Simon Peyton Jones and
Jean-Marc Eber and
Julian Seward Composing contracts: an adventure in
financial engineering (functional pearl) 280--292
Jan-Willem Maessen and
Xiaowei Shen Improving the Java memory model using
CRF . . . . . . . . . . . . . . . . . . 1--12
James Noble and
David Holmes and
John Potter Exclusion for composite objects . . . . 13--28
Peter A. Buhr and
Ashif S. Harji and
Philipp E. Lim and
Jiongxiong Chen Object-oriented real-time concurrency 29--46
Matthew Arnold and
Stephen Fink and
David Grove and
Michael Hind and
Peter F. Sweeney Adaptive optimization in the Jalapeño JVM 47--65
Mauricio Serrano and
Rajesh Bordawekar and
Sam Midkiff and
Manish Gupta Quicksilver: a quasi-static compiler for
Java . . . . . . . . . . . . . . . . . . 66--82
Ayal Zaks and
Vitaly Feldman and
Nava Aizikowitz Sealed calls in Java packages . . . . . 83--92
Ji Y. Lee and
Hye J. Kim and
Kyo C. Kang A real world object modeling method for
creating simulation environment of
real-time systems . . . . . . . . . . . 93--104
Rémi Bastide and
Philippe Palanque and
Ousmane Sy and
David Navarre Formal specification of CORBA services:
experience and lessons learned . . . . . 105--117
Jerry Kiernan and
Michael J. Carey Middleware object query processing with
deferred updates and autonomous sources 118--129
Curtis Clifton and
Gary T. Leavens and
Craig Chambers and
Todd Millstein MultiJava: modular open classes and
symmetric multiple dispatch for Java . . 130--145
Mirko Viroli and
Antonio Natali Parametric polymorphism in Java: an
approach to translation based on
reflective features . . . . . . . . . . 146--165
Serge Demeyer and
Stéphane Ducasse and
Oscar Nierstrasz Finding refactorings via change metrics 166--177
William Harrison and
Charles Barton and
Mukund Raghavachari Mapping UML designs to Java . . . . . . 178--187
Stephan Herrmann and
Mira Mezini PIROL: a case study for multidimensional
separation of concerns in software
engineering environments . . . . . . . . 188--207
Clyde Ruby and
Gary T. Leavens Safely creating correct subclasses
without seeing superclass code . . . . . 208--228
Mikel Luján and
T. L. Freeman and
John R. Gurd OoLALA: an object oriented analysis and
design of numerical linear algebra . . . 229--252
Alvaro Ortigosa and
Marcelo Campo and
Roberto Moriyón Towards agent-oriented assistance for
framework instantiation . . . . . . . . 253--263
Vijay Sundaresan and
Laurie Hendren and
Chrislain Razafimahefa and
Raja Vallée-Rai and
Patrick Lam and
Etienne Gagnon and
Charles Godin Practical virtual method call resolution
for Java . . . . . . . . . . . . . . . . 264--280
Frank Tip and
Jens Palsberg Scalable propagation-based call graph
construction algorithms . . . . . . . . 281--293
Kazuaki Ishizaki and
Motohiro Kawahito and
Toshiaki Yasue and
Hideaki Komatsu and
Toshio Nakatani A study of devirtualization techniques
for a Java$^{TM}$ Just-In-Time compiler 294--310
Neal Glew An efficient class and object encoding 311--324
Zhenyu Qian and
Allen Goldberg and
Alessandro Coglio A formal specification of Java$^{TM}$
class loading . . . . . . . . . . . . . 325--336
Derek Rayside and
Gerard T. Campbell An Aristotelian understanding of
object-oriented programming . . . . . . 337--353
Grzegorz Czajkowski Application isolation in the Java$^{TM}$
Virtual Machine . . . . . . . . . . . . 354--366
Ciarán Bryce and
Chrislain Razafimahefa An approach to safe object sharing . . . 367--381
David F. Bacon and
Robert E. Strom and
Ashis Tarafdar Guava: a dialect of Java without data
races . . . . . . . . . . . . . . . . . 382--400
David Nagle and
Steven Schlosser and
John Linwood Griffin and
Gregory Ganger Designing Computer Systems with
MEMS-based Storage . . . . . . . . . . . 1--12
Steven W. Schlosser and
John Linwood Griffin and
David F. Nagle and
Gregory R. Ganger Designing computer systems with
MEMS-based storage . . . . . . . . . . . 1--12
Kourosh Gharachorloo and
Madhu Sharma and
Simon Steely and
Stephen Van Doren Architecture and Design of AlphaServer
GS320 . . . . . . . . . . . . . . . . . 13--24
Milo M. K. Martin and
Daniel J. Sorin and
Anastassia Ailamaki and
Alaa R. Alameldeen and
Ross M. Dickson and
Carl J. Mauer and
Kevin E. Moore and
Manoj Plakal and
Mark D. Hill and
David A. Wood Timestamp Snooping: An Approach for
Extending SMPs . . . . . . . . . . . . . 25--36
Ashwini Nanda and
Kwok-Ken Mak and
Krishnan Sugavanam and
Ramendra K. Sahoo and
Vijayaraghavan Soundararajan and
T. Basil Smith MemorIES: A Programmable, Real-Time
Hardware Emulation Tool for
Multiprocessor Server Design . . . . . . 37--48
Jeff Gibson and
Robert Kunz and
David Ofelt and
Mark Horowitz and
John Hennessy and
Mark Heinrich FLASH vs. (simulated) FLASH: closing the
simulation loop . . . . . . . . . . . . 49--58
Mark Heinrich and
Jeff Givson and
Robert Kunz and
David Ofelt and
Mark Horowitz and
John Hennessy FLASH vs. (Simulated) FLASH: Closing the
Simulation Loop . . . . . . . . . . . . 49--58
Andy Chou and
Benjamin Chelf and
Dawson Engler and
Mark Heinrich Using Meta-level Compilation to Check
FLASH Protocol Code . . . . . . . . . . 59--70
Raoul A. F. Bhoedjang and
Kees Verstoep and
Tim Rühl and
Henri E. Bal and
Rutger F. H. Hofman Evaluating Design Alternatives for
Reliable Communication on High-Speed
Networks . . . . . . . . . . . . . . . . 71--81
Peter Mattson and
William J. Dally and
Scott W. Rixner and
Ujval J. Kapasi and
John D. Owens Communication Scheduling . . . . . . . . 82--92
Jason Hill and
Robert Szewczyk and
Alec Woo and
Seth Hollar and
David Culler and
Kristofer Pister System Architecture Directions for
Networked Sensors . . . . . . . . . . . 93--104
Alvin R. Lebeck and
Xiaobo Fan and
Heng Zeng and
Carla Ellis Power Aware Page Allocation . . . . . . 105--116
Emery D. Berger and
Kathryn S. McKinley and
Robert D. Blumofe and
Paul R. Wilson Hoard: A Scalable Memory Allocator for
Multithreaded Applications . . . . . . . 117--128
Krisztián Flautner and
Rich Uhlig and
Steve Reinhardt and
Trevor Mudge Thread Level Parallelism and Interactive
Performance of Desktop Applications . . 129--138
Motohiro Kawahito and
Hideaki Komatsu and
Toshio Nakatani Effective Null Pointer Check Elimination
Utilizing Hardware Trap . . . . . . . . 139--149
Youtao Zhang and
Jun Yang and
Rajiv Gupta Frequent Value Locality and
Value-Centric Data Cache Design . . . . 150--159
Michael Burrows and
Ulfar Erlingson and
Shun-Tak Leung and
Mark Vandevoorde and
Carl Waldspurger and
Kip Walker and
Bill Weihl Efficient and Flexible Value Sampling 160--167
David Lie and
Chandramohan Thekkath and
Mark Mitchell and
Patrick Lincoln and
Dan Boneh and
John Mitchell and
Mark Horowitz Architectural Support for Copy and
Tamper Resistant Software . . . . . . . 168--177
Todd Austin and
Jerome Burke and
John McDonald Architectural Support for Fast
Symmetric-Key Cryptography . . . . . . . 178--189
Jerome Burke and
John McDonald and
Todd Austin Architectural support for fast
symmetric-key cryptography . . . . . . . 178--189
John Kubiatowicz and
David Bindel and
Yan Chen and
Steven Czerwinski and
Patrick Eaton and
Dennis Geels and
Ramakrishan Gummadi and
Sean Rhea and
Hakim Weatherspoon and
Westley Weimer and
Chris Wells and
Ben Zhao OceanStore: An Architecture for
Global-Scale Persistent Storage . . . . 190--201
Evelyn Duesterwald and
Vasanth Bala Software Profiling for Hot Path
Prediction: Less is More . . . . . . . . 202--211
Rumi Zahir and
Jonathan Ross and
Dale Morris and
Drew Hess OS and Compiler Considerations in the
Design of the IA-64 Architecture . . . . 212--221
Daniel A. Connors and
Hillery C. Hunter and
Ben-Chung Cheng and
Wen-Mei W. Hwu Hardware Support for Dynamic Activation
of Compiler-Directed Computation Reuse 222--233
Allan Snavely and
Dean M. Tullsen Symbiotic Jobscheduling for a
Simultaneous Multithreading Processor 234--244
Joshua A. Redstone and
Susan J. Eggers and
Henry M. Levy An Analysis of Operating System Behavior
on a Simultaneous Multithreaded
Architecture . . . . . . . . . . . . . . 245--256
Karthik Sundaramoorthy and
Zachary Purser and
Eric Rotenberg Slipstream Processors: Improving both
Performance and Fault Tolerance . . . . 257--268
Anonymous Author Index . . . . . . . . . . . . . . 269--271
Seth Bergmann Conference Corner: Calendar . . . . . . 1--12
Anonymous Conference Corner: LCTES '01 Call for
Papers . . . . . . . . . . . . . . . . . 13--13
Brent W. Benson, Jr. Java reflections . . . . . . . . . . . . 14--18
Brent W. Benson, Jr. Java Reflections: Java Server Pages:
Servlets, Inside Out . . . . . . . . . . 14--18
Chris Jakeman Forth report . . . . . . . . . . . . . . 19--21
Chris Jakeman Forth in the UK . . . . . . . . . . . . 19--21
Jay Fenwick and
Cindy Norris Information for Authors . . . . . . . . 22--22
Jay Fenwick and
Cindy Norris Information for Past Authors . . . . . . 23--23
Rafael Corchuelo and
José A. Pérez and
Miguel Toro A Multiparty Coordination Aspect
Language . . . . . . . . . . . . . . . . 24--32
Bernd Kühl and
Axel-Tobias Schreiner An object-oriented LL(1) parser
generator . . . . . . . . . . . . . . . 33--40
David Basanta Gutiérrez and
Cándida Luengo Díez and
Raul Izquierdo Castanedo and
Jose Emilio Labra Gayo and
Juan Manuel Cueva Lovelle Improving the quality of compiler
construction with object-oriented
techniques . . . . . . . . . . . . . . . 41--50
Charles D. Knutson and
Timothy A. Budd and
Hugh Vidos Multiparadigm Design of a Simple
Relational Database . . . . . . . . . . 51--61
Martin Hirzel and
Amer Diwan On the Type Accuracy of Garbage
Collection . . . . . . . . . . . . . . . 1--11
Ran Shaham and
Elliot K. Kolodner and
Mooly Sagiv On the Effectiveness of GC in Java . . . 12--17
Bjarne Steensgaard Thread-Specific Heaps for Multi-Threaded
Programs . . . . . . . . . . . . . . . . 18--24
Henning Makholm A Region-Based Memory Manager for Prolog 25--34
Trishul Chilimbi and
Richard Jones and
Benjamin Zorn Designing a Trace Format for Heap
Allocation Events . . . . . . . . . . . 35--49
David Tarditi Compact Garbage Collection Tables . . . 50--58
Hans-J. Boehm Reducing Garbage Collector Cache Misses 59--64
Yoo C. Chung and
Soo-Mook Moon Memory Allocation with Lazy Fits . . . . 65--70
Gustavo Rodriguez-Rivera and
Mike Spertus and
Charles Fiterman Conservative Garbage Collection for
General Memory Allocators . . . . . . . 71--79
Timothy H. Heil and
James E. Smith Concurrent Garbage Collection Using
Hardware-Assisted Profiling . . . . . . 80--93
Manoj Plakal and
Charles N. Fischer Concurrent Garbage Collection Using
Program Slices on Multithreaded
Processors . . . . . . . . . . . . . . . 94--100
Richard L. Hudson and
J. Eliot B. Moss and
Sreenivas Subramoney and
Weldon Washburn Cycles to Recycle: Garbage Collection on
the IA-64 . . . . . . . . . . . . . . . 101--110
Robert Fitzgerald and
David Tarditi The Case for Profile-Directed Selection
of Garbage Collectors . . . . . . . . . 111--120
Ole Agesen and
Alex Garthwaite Efficient Object Sampling via Weak
References . . . . . . . . . . . . . . . 121--126
Timothy L. Harris Dynamic Adaptive Pre-Tenuring . . . . . 127--136
Darko Stefanovi\'c and
Kathryn S. McKinley and
J. Eliot B. Moss On models for object lifetime
distributions . . . . . . . . . . . . . 137--142
Tony Printezis and
David Detlefs A Generational Mostly-Concurrent Garbage
Collector . . . . . . . . . . . . . . . 143--154
Tamar Domani and
Elliot K. Kolodner and
Ethan Lewis and
Eliot E. Salant and
Katherine Barabash and
Itai Lahan and
Yossi Levanoni and
Erez Petrank and
Igor Yanorer Implementing an On-the-Fly Garbage
Collector for Java . . . . . . . . . . . 155--166
Peter Dickman Diffusion Tree Restructuring for
Indirect Reference Counting . . . . . . 167--177
Paul Frenger Forth: Extreme Forth . . . . . . . . . . 20--23
Rajeev Kumar A neural net compiler system for
hierarchical organization . . . . . . . 26--36
Boris Sunik Definition of open language . . . . . . 37--46
Yukong Zhang and
Young-Jun Kwon and
Hyuk Jae Lee A systematic generation of initial
register-reuse chains for dependence
minimization . . . . . . . . . . . . . . 47--54
John C. Mitchell Programming language methods in computer
security . . . . . . . . . . . . . . . . 1--3
Davide Sangiorgi Extensionality and Intensionality of the
Ambient Logics . . . . . . . . . . . . . 4--13
Samin S. Ishtiaq and
Peter W. O'Hearn BI as an Assertion Language for Mutable
Data Structures . . . . . . . . . . . . 14--26
Eran Yahav Verifying safety properties of
concurrent Java programs using
$3$-valued logic . . . . . . . . . . . . 27--40
Martin Odersky and
Christoph Zenger and
Matthias Zenger Colored local type inference . . . . . . 41--53
Jakob Rehof and
Manuel Fähndrich Type-base flow analysis: from
polymorphic subtyping to
CFL-reachability . . . . . . . . . . . . 54--66
Haruo Hosoya and
Benjamin Pierce Regular expression pattern matching for
XML . . . . . . . . . . . . . . . . . . 67--80
Chin Soon Lee and
Neil D. Jones and
Amir M. Ben-Amram The size-change principle for program
termination . . . . . . . . . . . . . . 81--92
David Monniaux An abstract Monte-Carlo method for the
analysis of probabilistic programs . . . 93--101
Harald Ganzinger Efficient deductive methods for program
analysis . . . . . . . . . . . . . . . . 102--103
Martín Abadi and
Cédric Fournet Mobile values, new names, and secure
communication . . . . . . . . . . . . . 104--115
Asis Unyapoth and
Peter Sewell Nomadic pict: correct communication
infrastructure for mobile computation 116--127
Atsushi Igarashi and
Naoki Kobayashi A generic type system for the
Pi-calculus . . . . . . . . . . . . . . 128--141
George C. Necula and
S. P. Rahul Oracle-based checking of untrusted
software . . . . . . . . . . . . . . . . 142--154
Cristiano Calcagno Stratified operational semantics for
safety and correctness of the region
calculus . . . . . . . . . . . . . . . . 155--165
Daniel C. Wang and
Andrew W. Appel Type-preserving garbage collectors . . . 166--178
Mahmut Taylan Kandemir A compiler technique for improving
whole-program locality . . . . . . . . . 179--192
Cormac Flanagan and
James B. Saxe Avoiding exponential explosion:
generating compact verification
conditions . . . . . . . . . . . . . . . 193--205
Karthikeyan Bhargavan and
Satish Chandra and
Peter J. McCann and
Carl A. Gunter What packets may come: automata for
network monitoring . . . . . . . . . . . 206--219
Robin Milner Computational flux . . . . . . . . . . . 220--221
Michele Bugliesi and
Giuseppe Castagna Secure safe ambients . . . . . . . . . . 222--235
Peter Sewell Modules, abstract types, and distributed
versioning . . . . . . . . . . . . . . . 236--247
Andrew D. Gordon and
Don Syme Typing a multi-language intermediate
code . . . . . . . . . . . . . . . . . . 248--260
Mark Shields and
Erik Meijer Type-indexed rows . . . . . . . . . . . 261--275
Joseph (Yossi) Gil Subtyping arithmetical types . . . . . . 276--289
Jérôme Vouillon Combining subsumption and binary
methods: an object calculus with views 290--303
Thomas Ball and
Hans Boehm A modest proposal for SIGPLAN in the
21st Century . . . . . . . . . . . . . . 1--2
Thomas Ball and
Hans Boehm SIGPLANet . . . . . . . . . . . . . . . 1--2
Ron Cytron and
Matthias Felleisen Computing Curricula 2001 Draft: SIGPLAN
Response to the Ironman Draft of the
Computing Curricula 2001 . . . . . . . . 3--4
Jay Fenwick and
Cindy Norris and
Ron Cytron and
Matthias Felleisen Computing Curricula 2001 draft . . . . . 3--4
Seth Bergmann Conference Corner: Calendar . . . . . . 5--20
Paul Frenger Close encounters of the Forth kind . . . 21--24
Brian McNamara and
Yannis Smaragdakis Functional programming in C++ using the
FC++ library . . . . . . . . . . . . . . 25--30
Brian McNamara and
Yannis Smaragdakis Functional Programming in C++ using the
FC++ Library . . . . . . . . . . . . . . 25--30
Jay Fenwick and
Cindy Norris Information for Authors . . . . . . . . 31--31
Jay Fenwick and
Cindy Norris Information for Past Authors . . . . . . 32--32
Zhenqiang Chen and
Baowen Xu Slicing Object-Oriented Java Programs 33--40
Zhenqiang Chen and
Baowen Xu Slicing Concurrent Java Programs . . . . 41--47
Wang Shaofeng and
Yang Fuquing and
Sun Jiaguang Some issues on the translator of
Smalltalk to C++ . . . . . . . . . . . . 48--55
Shaofeng Wang and
Fuqing Yang and
Jiaguang Sun Some issues on the translator of
Smalltalk to C++ . . . . . . . . . . . . 48--55
Andrew Kennedy and
Don Syme Design and Implementation of Generics
for the .NET Common Language Runtime . . 1--12
Michael Hicks and
Jonathan T. Moore and
Scott Nettles Dynamic Software Updating . . . . . . . 13--23
Nevin Heintze and
Olivier Tardieu Demand-Driven Pointer Analysis . . . . . 24--34
Frédéric Vivien and
Martin Rinard Incrementalized pointer and escape
analysis . . . . . . . . . . . . . . . . 35--46
Frederic Vivient and
Martin Rinard Incrementalized Pointer and Escape
Analysis . . . . . . . . . . . . . . . . 35--46
Rakesh Ghiya and
Daniel Lavery and
David Sehr On the Importance of Points-to Analysis
and Other Memory Disambiguation Methods
for C Programs . . . . . . . . . . . . . 47--58
Robert DeLine and
Manuel Fähndrich Enforcing High-Level Protocols in
Low-Level Software . . . . . . . . . . . 59--69
David Gay and
Alex Aiken Language Support for Regions . . . . . . 70--80
Stefan Monnier and
Bratin Saha and
Zhong Shao Principled Scavenging . . . . . . . . . 81--91
David F. Bacon and
Clement R. Attanasio and
Han B. Lee and
V. T. Rajan and
Stephen Smith Java without the coffee breaks: a
nonintrusive multiprocessor garbage
collector . . . . . . . . . . . . . . . 92--103
Ran Shaham and
Elliot K. Kolodner and
Mooly Sagiv Heap Profiling for Space-Efficient Java 104--113
Emery D. Berger and
Benjamin G. Zorn and
Kathryn S. McKinley Composing High-Performance Memory
Allocators . . . . . . . . . . . . . . . 114--124
Perry Cheng and
Guy E. Blelloch A Parallel, Real-Time Garbage Collector 125--136
Wolfram Amme and
Niall Dalton and
Jeffery von Ronne and
Michael Franz SafeTSA: A Type Safe and Referentially
Secure Mobile-Code Representation Based
on Static Single Assignment Form . . . . 137--147
William S. Evans and
Christopher W. Fraser Bytecode Compression via Profiled
Grammar Rewriting . . . . . . . . . . . 148--155
Chandra Krintz and
Brad Calder Using annotations to reduce dynamic
optimization time . . . . . . . . . . . 156--167
Matthew Arnold and
Barbara G. Ryder A Framework for Reducing the Cost of
Instrumented Code . . . . . . . . . . . 168--179
Youtao Zhang and
Rajiv Gupta Timestamped Whole Program Path
Representation and its Applications . . 180--190
Trishul M. Chilimbi Efficient Representations and
Abstractions for Quantifying and
Exploiting Data Reference Locality . . . 191--202
Thomas Ball and
Rupak Majumdar and
Todd Millstein and
Sriram K. Rajamani Automatic Predicate Abstraction of C
Programs . . . . . . . . . . . . . . . . 203--213
Aneesh Aggarwal and
Keith H. Randall Related Field Analysis . . . . . . . . . 214--220
Anders Mòller and
Michael I. Schwartzbach The Pointer Assertion Logic Engine . . . 221--231
William Thies and
Frédéric Vivien and
Jeffrey Sheldon and
Saman Amarasinghe A Unified Framework for Schedule and
Storage Optimization . . . . . . . . . . 232--242
Andrew W. Appel and
Lal George Optimal Spilling for CISC Machines with
Few Registers . . . . . . . . . . . . . 243--253
Nevin Heintze and
Olivier Tardieu Ultra-fast Aliasing Analysis using CLA:
A Million Lines of C Code in a Second 254--263
David R. Hanson and
Todd A. Proebsting Dynamic Variables . . . . . . . . . . . 264--273
Simon Marlow and
Simon Peyton Jones and
Andrew Moran and
John Reppy Asynchronous Exceptions in Haskell . . . 274--285
Siddhartha Chatterjee and
Erin Parker and
Philip J. Hanlon and
Alvin R. Lebeck Exact Analysis of the Cache Behavior of
Nested Loops . . . . . . . . . . . . . . 286--297
Jianxin Xiong and
Jeremy Johnson and
Robert Johnson and
David Padua SPL: A Language and Compiler for DSP
algorithms . . . . . . . . . . . . . . . 298--308
Sanjeev Kumar and
Yitzhak Mandelbaum and
Xiang Yu and
Kai Li ESP: A Language for Programmable Devices 309--320
Eric C. Schnarr and
Mark D. Hill and
James R. Larus Facile: A Language and Compiler for
High-Performance Processor Simulators 321--331
Anonymous Author Index . . . . . . . . . . . . . . 333--333
Kathleen Knobe and
Wilson Hsieh and
Uli Kremer Executive Committee News: SIGPLAN's
Professional Activities Committee . . . 1--2
Anonymous Conference Corner: Calendar . . . . . . 3--18
Pieter Thiemann Call for Papers --- PEPM'02: 2002 ACM
Sigplan Workshop on Partial Evaluation
and Semantics-Based Program
Manipulation, Portland, Oregon, USA,
January 14--15, 2002, Preceding POPL'02 19--19
Joe Bergin Curricular Patterns: The Undergraduate
Language Course: What To Do? . . . . . . 20--22
Joe Bergin The undergraduate language course: what
to do? . . . . . . . . . . . . . . . . . 20--22
Paul Frenger Is Forth dead? . . . . . . . . . . . . . 23--25
Paul Frenger Forth Report: Is Forth Dead? . . . . . . 23--25
Jay Fenwick and
Cindy Norris Information for Authors . . . . . . . . 26--26
Jay Fenwick and
Cindy Norris Information for Past Authors . . . . . . 27--27
Tao Li and
XiaoJie Liu The Denotational Semantics of NIPL . . . 28--37
Alexander Gofen From Pascal to Delphi to Object
Pascal-2000 . . . . . . . . . . . . . . 38--49
Sheng Yu Class-is-type is inadequate for object
reuse . . . . . . . . . . . . . . . . . 50--59
Ian Foster Parallel computing in 2010:
opportunities and challenges in a
networked world . . . . . . . . . . . . 1--1
Seon Wook Kim and
Chong-liang Ooi and
Rudolf Eigenmann and
Babak Falsafi and
T. N. Vijaykumar Reference idempotency analysis: a
framework for optimizing speculative
execution . . . . . . . . . . . . . . . 2--11
Alexandru Salcianu and
Martin Rinard Pointer and escape analysis for
multithreaded programs . . . . . . . . . 12--23
David S. Wise and
Jeremy D. Frens and
Yuhong Gu and
Gregory A. Alexander Language support for Morton-order
matrices . . . . . . . . . . . . . . . . 24--33
Rob V. van Nieuwpoort and
Thilo Kielmann and
Henri E. Bal Efficient load balancing for wide-area
divide-and-conquer applications . . . . 34--43
Michael L. Scott and
William N. Scherer Scalable queue-based spin locks with
timeout . . . . . . . . . . . . . . . . 44--52
Honghui Lu and
Alan L. Cox and
Willy Zwaenepoel Contention elimination by replication of
sequential sections in distributed
shared memory programs . . . . . . . . . 53--61
Donald G. Morris and
David K. Lowenthal Accurate data redistribution cost
estimation in software distributed
shared memory systems . . . . . . . . . 62--71
Umit Rencuzogullari and
Sandhya Dwardadas Dynamic adaptation to available
resources for parallel computing in an
autonomous network of workstations . . . 72--81
Andrew A. Chien Parallel programming challenges for
Internet-scale computing (entropia) . . 82--82
R. Veldema and
R. F. H. Hofman and
R. A. F. Bhoedjang and
C. J. H. Jacobs and
H. E. Bal Source-level global optimizations for
fine-grain distributed shared memory
systems . . . . . . . . . . . . . . . . 83--92
Michael J. Voss and
Rudolf Eigemann High-level adaptive program optimization
with ADAPT . . . . . . . . . . . . . . . 93--102
Amy W. Lim and
Shih-Wei Liao and
Monica S. Lam Blocking and array contraction across
arbitrarily nested loops using affine
partitioning . . . . . . . . . . . . . . 103--112
Enrique V. Carrera and
Ricardo Bianchini Efficiency vs. portability in
cluster-based network servers . . . . . 113--122
Jeffrey S. Vetter and
Michael O. McCracken Statistical scalability analysis of
communication operations in distributed
applications . . . . . . . . . . . . . . 123--132
Fumihiko Ino and
Noriyuki Fujimoto and
Kenichi Hagihara LogGPS: a parallel computational model
for synchronization analysis . . . . . . 133--142
David Kuck Peer to peer and distributed computing 143--143
Sheayun Lee and
Andreas Ermedahl and
Sang Lyul Min and
Naehyuck Chang An Accurate Instruction-Level Energy
Consumption Model for Embedded RISC
Processors . . . . . . . . . . . . . . . 1--10
Minyoung Kim and
Soonhoi Ha Hybrid Run-time Power Management
Technique for Real-time Embedded System
with Voltage Scalable Processor . . . . 11--19
Dong-In Kang and
Stephen Crago and
Jinwoo Suh Power-Aware Design Synthesis Techniques
for Distributed Real-Time Systems . . . 20--28
Bjorn De Sutter and
Bruno De Bus and
Koen De Bosschere and
Saumya Debray Combining Global Code and Data
Compaction . . . . . . . . . . . . . . . 29--38
Bjorn De Sutter and
Bruno De Bus and
Koen De Bosschere and
Saumya Debray Combining Global Code and Data
Compaction . . . . . . . . . . . . . . . 29--38
Jinpyo Park and
Je-Hyung Lee and
Soo-Mook Moon Register Allocation for Banked Register
File . . . . . . . . . . . . . . . . . . 39--47
Xianglong Huang and
Steve Carr and
Philip Sweany Loop Transformations for Architectures
with Partitioned Register Banks . . . . 48--55
Sidney Cadot and
Frits Kuijlman and
Koen Langendoen and
Kees van Reeuwijk and
Henk Sips ENSEMBLE: A Communication Layer for
Embedded Multi-Processor Systems . . . . 56--63
Thomas A. Henzinger and
Benjamin Horowitz and
Christoph Meyer Kirsch Embedded Control Systems Development
with Giotto . . . . . . . . . . . . . . 64--72
Luigi Palopoli and
Giuseppe Lipari and
Luca Abeni and
Marco Di Natale and
Paolo Ancilotti and
Fabio Conticelli A tool for simulation and fast
prototyping of embedded control systems 73--81
A. Bakshi and
V. K. Prasanna and
A. Ledeczi MILAN: A Model Based Integrated
Simulation Framework for Design of
Embedded Systems . . . . . . . . . . . . 82--87
Emilio Vivancos and
Christopher Healy and
Frank Mueller and
David Whalley Parametric Timing Analysis . . . . . . . 88--93
Dirk Ziegenbein and
Fabian Wolf and
Kai Richter and
Marek Jersak and
Rolf Ernst Interval-Based Analysis of Software
Processes . . . . . . . . . . . . . . . 94--101
Leena Unnikrishnan and
Scott D. Stoller and
Yanhong A. Liu Automatic Accurate Live Memory Analysis
for Garbage-Collected Languages . . . . 102--111
Henrik Theiling Generating Decision Trees for Decoding
Binaries . . . . . . . . . . . . . . . . 112--120
Fabrice Mérillion and
Gilles Muller Dealing with Hardware in Embedded
Software: A General Framework Based on
the Devil Language . . . . . . . . . . . 121--127
Fabrice Merillon and
Gilles Muller Dealing with Hardware in Embedded
Software: A General Framework Based on
the Devil Language . . . . . . . . . . . 121--127
Ismail Kadayif and
Mahmut Taylan Kandemir and
Narayanan Vijaykrishnan and
Mary Jane Irwin and
Jagannathan Ramanujam Morphable Cache Architectures: Potential
Benefits . . . . . . . . . . . . . . . . 128--137
Elana Granston and
Eric Stotzer and
Joe Zbiciak Software Pipelining Irregular Loops On
the TMS320C6000 VLIW DSP Architecture 138--144
Daniel Kästner and
Sebastian Winkel ILP-based Instruction Scheduling for
IA-64 . . . . . . . . . . . . . . . . . 145--154
Jens Wagner and
Rainer Leupers C Compiler Design for an Industrial
Network Processor . . . . . . . . . . . 155--164
Christoph Keßler and
Andrzej Bednarski A Dynamic Programming Approach to
Optimal Integrated Code Generation . . . 165--174
Daniel M. Yellin Stuck in the Middle: Challenges and
Trends in Optimizing Middleware . . . . 175--180
Karin Högstedt and
Doug Kimelman and
Nan Wang Optimizing Component Interaction . . . . 181--181
Mark Wegman Optimizing Component Interaction . . . . 181--181
James R. Larus and
Michael Parkes Using Cohort Scheduling to Enhance
Server Performance (Extended Abstract) 182--187
Sanjai Narain and
Ravichander Vaidyanathan and
Stanley Moyer and
William Stephens and
Kirthika Parmeswaran and
Abdul Rahim Shareef Middleware for Building Adaptive Systems
via Configuration . . . . . . . . . . . 188--195
Pradeep Gore and
Ron Cytron and
Douglas Schmidt and
Carlos O'Ryan Designing and Optimizing a Scalable
CORBA Notification Service . . . . . . . 196--204
Ossama Othman and
Douglas C. Schmidt Issues in the Design of Adaptive
Middleware Load Balancing . . . . . . . 205--213
Irfan Pyarali and
Marina Spivak and
Ron Cytron and
Douglas C. Schmidt Evaluating and Optimizing Thread Pool
Strategies for Real-Time CORBA . . . . . 214--222
Darrell Brunsch and
Carlos O'Ryan and
Douglas C. Schmidt Designing an Efficient and Scalable
Server-side Asynchrony Model for CORBA 223--229
Yamuna Krishnamurthy and
Vishal Kachroo and
David A. Karr and
Craig Rodrigues and
Joseph P. Loyall and
Richard Schantz and
Douglas C. Schmidt Integration of QoS-Enabled Distributed
Object Computing Middleware for
Developing Next-Generation Distributed
Applications . . . . . . . . . . . . . . 230--237
Vikram Adve and
Vinh Vi Lam and
Brian Ensink Language and Compiler Support for
Adaptive Distributed Applications . . . 238--246
Edward A. Lee Embedded Software from Concurrent
Component Models . . . . . . . . . . . . ??
Krishna V. Palem What is a compiler when the architecture
is not hard? . . . . . . . . . . . . . . ??
Hans Boehm Letter from the Newly Elected Chair . . 1--2
Dave Whalley Letter from the LCTES Steering Committee 3--3
Anonymous Calendar . . . . . . . . . . . . . . . . 4--16
Anonymous In parallel . . . . . . . . . . . . . . 17--17
Anonymous LCTES'02 and SCOPES'02 . . . . . . . . . 18--18
Rex Page Functional programming, and where you
can put it . . . . . . . . . . . . . . . 19--24
Anonymous ASTs for optimizing compilers . . . . . 25--30
Chris Clark ASTs for Optimizing Compilers . . . . . 25--30
Thomas W. Christopher Test Programs to Observe Parallelism . . 31--36
Anonymous Information for Authors . . . . . . . . 37--37
Anonymous Information for Past Authors . . . . . . 38--38
Ming-Yuan Zhu Denotational Semantics of Programming
Languages and Compiler Generation in
PowerEpsilon . . . . . . . . . . . . . . 39--53
Ming-Yuan Zhu Formal specifications of debuggers . . . 54--63
Holger M. Kienle Using \tt smgn for Rapid Prototyping of
Small Domain-Specific Languages . . . . 64--73
David L. Moore \tt smgn: Some historical remarks . . . 74--76
Michael L. Gassanenko About Code Layout for Lisp . . . . . . . 77--80
Lunjin Lu On Dart-Zobel Algorithm for Testing
Regular Type Inclusion . . . . . . . . . 81--85
Wang Shaofeng and
Sun Jiaguang A framework design of workflow
management system with Java RMI . . . . 86--93
Shaofeng Wang and
Jiaguang Sun A Framework Design for Workflow
Management System with Java RMI . . . . 86--93
Anonymous Functional programming . . . . . . . . . ??
Anonymous Practical parsing patterns . . . . . . . ??
Anonymous Technical correspondence . . . . . . . . ??
Andrew M. Pitts A Fresh Approach to Representing Syntax
with Static Binders in Functional
Programming . . . . . . . . . . . . . . 1--1
Matthew Fluet and
Stephen Weeks Contification using Dominators . . . . . 2--13
Allyn Dimock and
Ian Westmacott and
Robert Muller and
Franklyn Turbak and
J. B. Wells Functioning without Closure: Type-Safe
Customized Function Representations for
Standard ML . . . . . . . . . . . . . . 14--25
Fabrice Le Fessant and
Luc Maranget Optimizing pattern matching . . . . . . 26--37
Fabrice Le Fessant and
Luc Maranget Optimizing Pattern Matching . . . . . . 26--37
Matthias Neubauer and
Michael Sperber Down with Emacs Lisp: Dynamic Scope
Analysis . . . . . . . . . . . . . . . . 38--49
Claudio V. Russo Recursive Structures for Standard ML . . 50--61
Dominic Duggan Type-based hot swapping of running
modules (extended abstract) . . . . . . 62--73
Steven E. Ganz and
Amr Sabry and
Walid Taha Macros as Multi-Stage Computations:
Type-Safe, Generative, Binding Macros in
MacroML . . . . . . . . . . . . . . . . 74--85
Tim Sheard Generic Unification via Two-Level Types
and Parameterized Modules . . . . . . . 86--97
Tyng-Ruey Chuang Generic Validation of Structural Content
with Parametric Modules . . . . . . . . 98--109
Ralf Hinze A Simple Implementation Technique for
Priority Search Queues . . . . . . . . . 110--121
Michael Sperber Developing a Stage Lighting System from
Scratch . . . . . . . . . . . . . . . . 122--133
Saswat Anand and
Wei-Ngan Chin and
Siau-Cheng Khoo Charting Patterns on Price History . . . 134--145
Zhanyong Wan and
Walid Taha and
Paul Hudak Real-time FRP . . . . . . . . . . . . . 146--156
George Russell Events in Haskell, and How to Implement
Them . . . . . . . . . . . . . . . . . . 157--168
Hongwei Xi and
Robert Harper A Dependently Typed Assembly Language 169--180
Hongwei Xi and
Robert Harper A dependently typed assembly language 169--180
David Walker and
Kevin Watkins On regions and linear types (extended
abstract) . . . . . . . . . . . . . . . 181--192
Olaf Chitil Compositional Explanation of Types and
Algorithmic Debugging of Type Errors . . 193--204
Manuel M. T. Chakravarty and
Gabriele Keller Functional Array Fusion . . . . . . . . 205--216
Aleksandar Nanevski and
Guy Blelloch and
Robert Harper Automatic Generation of Staged Geometric
Predicates . . . . . . . . . . . . . . . 217--228
Ross Paterson A New Notation for Arrows . . . . . . . 229--240
Matthias Zenger and
Martin Odersky Extensible Algebraic Datatypes with
Defaults . . . . . . . . . . . . . . . . 241--252
Bernd Grobauer Cost Recurrences for DML Programs . . . 253--264
Jörgen Gustavsson and
David Sands Possibilities and Limitations of
Call-by-Need Space Improvement . . . . . 265--276
Anonymous Author Index . . . . . . . . . . . . . . 277--277
Anonymous Invited talk 1 . . . . . . . . . . . . . ??
Anonymous Session 1 . . . . . . . . . . . . . . . ??
Anonymous Session 2 . . . . . . . . . . . . . . . ??
Anonymous Session 3 . . . . . . . . . . . . . . . ??
Anonymous Session 4 . . . . . . . . . . . . . . . ??
Anonymous Session 5 . . . . . . . . . . . . . . . ??
Anonymous Session 6 . . . . . . . . . . . . . . . ??
Anonymous Session 7 . . . . . . . . . . . . . . . ??
Lennart Augustsson Bluespec --- a hardware description
language . . . . . . . . . . . . . . . . ??
Matteo Frigo The Fastest Fourier Transform in the
West . . . . . . . . . . . . . . . . . . ??
Robert Bruce Findler and
Matthias Felleisen Contract soundness for object-oriented
languages . . . . . . . . . . . . . . . 1--15
D. Ancona and
G. Lagorio and
E. Zucca A core calculus for Java exceptions . . 16--30
Jonthan Bachrach and
Keith Playford The Java Syntactic Extender (JSE) . . . 31--42
Atanas Rountev and
Ana Milanova and
Barbara G. Ryder Points-to analysis for Java using
annotated constraints . . . . . . . . . 43--55
Chandrasekhar Boyapati and
Martin Rinard A parameterized type system for
race-free Java programs . . . . . . . . 56--69
Christoph von Praun and
Thomas R. Gross Object race detection . . . . . . . . . 70--82
Takeshi Ogasawara and
Hideaki Komatsu and
Toshio Nakatani A study of exception handling and its
dynamic optimization in Java . . . . . . 83--95
Yoav Zibin and
Joseph Yossi Gil Efficient subtyping tests with
PQ-encoding . . . . . . . . . . . . . . 96--107
Bowen Alpern and
Anthony Cocchi and
Stephen Fink and
David Grove Efficient implementation of Java
interfaces: Invokeinterface considered
harmless . . . . . . . . . . . . . . . . 108--124
Grzegorz Czajkowski and
Laurent Daynés Multitasking without compromise: a
virtual machine evolution . . . . . . . 125--138
Walter Binder and
Jane G. Hulaas and
Alex Villazón Portable resource control in Java . . . 139--155
Hiroaki Nakamura Incremental computation of complex
object queries . . . . . . . . . . . . . 156--165
John Whaley Partial method compilation using dynamic
profile information . . . . . . . . . . 166--179
Toshio Suganuma and
Toshiaki Yasue and
Motohiro Kawahito and
Hideaki Komatsu and
Toshio Nakatani A dynamic optimization framework for a
Java just-in-time compiler . . . . . . . 180--195
Igor Pechtchanski and
Vivek Sarkar Dynamic optimistic interprocedural
analysis: a framework and an application 195--210
Sean McDirmid and
Matthew Flatt and
Wilson C. Hsieh Jiazzi: new-age components for
old-fashioned Java . . . . . . . . . . . 211--222
Dominic Duggan and
Ching-Ching Techaubol Modular mixin-based inheritance for
application frameworks . . . . . . . . . 223--240
Christian Grothoff and
Jens Palsberg and
Jan Vitek Encapsulating objects with confined
types . . . . . . . . . . . . . . . . . 241--253
Patrick Th. Eugster and
Rachid Guerraoui and
Christian Heide Damm On objects and events . . . . . . . . . 254--269
Joost Visser Visitor combination and traversal
control . . . . . . . . . . . . . . . . 270--282
Klaus Ostermann and
Mira Mezini Object-oriented composition untangled 283--299
Michele Lanza and
Stéphane Ducasse A categorization of classes based on the
visualization of their internal
structure: the class blueprint . . . . . 300--311
Mary Jean Harrold and
James A. Jones and
Tongyu Li and
Donglin Liang and
Ashish Gujarathi Regression test selection for Java
software . . . . . . . . . . . . . . . . 312--326
Dirk Riehle and
Steven Fraleigh and
Dirk Bucka-Lassen and
Nosa Omorogbe The architecture of a UML virtual
machine . . . . . . . . . . . . . . . . 327--341
Stephen M. Blackburn and
Sharad Singhai and
Matthew Hertz and
Kathryn S. McKinely and
J. Eliot B. Moss Pretenuring for Java . . . . . . . . . . 342--352
Tim Brecht and
Eshrat Arjomandi and
Chang Li and
Hang Pham Controlling garbage collection and heap
growth to reduce the execution time of
Java applications . . . . . . . . . . . 353--366
Yossi Levanoni and
Erez Petrank An on-the-fly reference counting garbage
collector for Java . . . . . . . . . . . 367--380
John Vlissides and
Doug Lea Introduction to this issue's special
section on Intriguing Technology from
OOPSLA . . . . . . . . . . . . . . . . . 1--1
Anonymous Conference Corner: Calendar . . . . . . 2--11
Anonymous Conference Corner: International Corner
on Software Engineering (ICSE) . . . . . 12--12
Anonymous Conference Corner: Foundations of
Software Engineering (FSE) . . . . . . . 13--13
Anonymous Conference Corner: Program Analysis for
System Tools and Engineering (PASTE) . . 14--14
Anonymous Conference Corner: International
Symposium on Memory Management (ISMM) 15--15
Paul Frenger Forth mindstorms . . . . . . . . . . . . 16--19
Carlos Varela and
Gul Agha Programming Dynamically Reconfigurable
Open Systems with SALSA . . . . . . . . 20--34
Jörg Nolte and
Yutaka Ishikawa and
Mitsuhisa Sato TACO --- Prototyping High-Level
Object-Oriented Programming Constructs
by Means of Template Based Programming
Techniques . . . . . . . . . . . . . . . 35--49
Joseph W. Yoder and
Federico Balaguer and
Ralph Johnson Architecture and Design of Adaptive
Object-Models . . . . . . . . . . . . . 50--60
Richard Pawson and
Robert Matthews Naked objects: a technique for designing
more expressive systems . . . . . . . . 61--67
Jay Fenwick and
Cindy Norris Information for Authors . . . . . . . . 68--68
Jay Fenwick and
Cindy Norris Information for Past Authors . . . . . . 69--69
Baowen Xu and
Zhenqiang Chen Dependence Analysis for Recursive Java
Programs . . . . . . . . . . . . . . . . 70--76
Peter Dolog and
Valentino Vrani\'c and
Mária Bieliková Representing Change By Aspect . . . . . 77--83
Enis Avdi\vcau\vsevi\'c and
Mitja Leni\vc and
Marjan Mernik and
Viljem \vZumer AspectCOOL: An experiment in design and
implementation of aspect-oriented
language . . . . . . . . . . . . . . . . 84--94
Anonymous Forth . . . . . . . . . . . . . . . . . ??
Anonymous Intriguing technology from OOPSLA . . . ??
Anonymous Technical correspondence . . . . . . . . ??
Thomas Ball and
Sriram K. Rajamani The \sc Slam project: debugging system
software via static analysis . . . . . . 1--3
Glenn Ammons and
Rastislav Bodík and
James R. Larus Mining specifications . . . . . . . . . 4--16
Viktor Kuncak and
Patrick Lam and
Martin Rinard Role analysis . . . . . . . . . . . . . 17--32
Martín Abadi and
Bruno Blanchet Analyzing security protocols with
secrecy types and logic programs . . . . 33--44
Sagar Chaki and
Sriram K. Rajamani and
Jakob Rehof Types as models: model checking
message-passing programs . . . . . . . . 45--57
Thomas A. Henzinger and
Ranjit Jhala and
Rupak Majumdar and
Grégoire Sutre Lazy abstraction . . . . . . . . . . . . 58--70
Massimo Merro and
Matthew Hennessy Bisimulation congruences in safe
ambients . . . . . . . . . . . . . . . . 71--80
Kohei Honda and
Nobuko Yoshida A uniform type structure for secure
information flow . . . . . . . . . . . . 81--92
Hans-J. Boehm Bounding space usage of conservative
garbage collectors . . . . . . . . . . . 93--100
Erez Petrank and
Dror Rawitz The hardness of cache conscious data
placement . . . . . . . . . . . . . . . 101--112
Matthai Philipose and
Craig Chambers and
Susan J. Eggers Towards automatic construction of staged
compilers . . . . . . . . . . . . . . . 113--125
Matthias Felleisen From POPL to the classroom and back . . 126--127
George C. Necula and
Scott McPeak and
Westley Weimer CCured: type-safe retrofitting of legacy
code . . . . . . . . . . . . . . . . . . 128--139
Shai Rubin and
Rastislav Bodík and
Trishul Chilimbi An efficient profile-analysis framework
for data-layout optimizations . . . . . 140--153
Norman Ramsey and
Avi Pfeffer Stochastic lambda calculus and monads of
probability distributions . . . . . . . 154--165
Anindya Banerjee and
David A. Naumann Representation independence, confinement
and access control [extended abstract] 166--177
Patrick Cousot and
Radhia Cousot Systematic design of program
transformation frameworks by abstract
interpretation . . . . . . . . . . . . . 178--190
Cormac Flanagan and
Shaz Qadeer Predicate abstraction for software
verification . . . . . . . . . . . . . . 191--202
Zhendong Su and
Alexander Aiken and
Joachim Niehren and
Tim Priesnitz and
Ralf Treinen The first-order theory of subtyping
constraints . . . . . . . . . . . . . . 203--216
Zhong Shao and
Bratin Saha and
Valery Trifonov and
Nikolaos Papaspyrou A type system for certified binaries . . 217--232
Matthias Neubauer and
Peter Thiemann and
Martin Gasbichler and
Michael Sperber Functional logic overloading . . . . . . 233--244
Rajit Manohar Scalable formal design methods for
asynchronous VLSI . . . . . . . . . . . 245--246
Umut A. Acar and
Guy E. Blelloch and
Robert Harper Adaptive functional programming . . . . 247--259
Martin Hofmann The strength of non-size increasing
computation . . . . . . . . . . . . . . 260--269
Sorin Lerner and
David Grove and
Craig Chambers Composing dataflow analyses and
transformations . . . . . . . . . . . . 270--282
David Lacey and
Neil D. Jones and
Eric Van Wyk and
Carl Christian Frederiksen Proving correctness of compiler
optimizations by temporal logic . . . . 283--294
Yefim Shuf and
Manish Gupta and
Rajesh Bordawekar and
Jaswinder Pal Singh Exploiting prolific types for memory
management and optimizations . . . . . . 295--306
Cédric Fournet and
Andrew D. Gordon Stack inspection: theory and variants 307--318
François Pottier and
Vincent Simonet Information flow inference for ML . . . 319--330
Atsushi Igarashi and
Naoki Kobayashi Resource usage analysis . . . . . . . . 331--342
Julian V. Noble Forth report: jump tables and state
machines . . . . . . . . . . . . . . . . 14--19
Thomas W. Christopher In parallel: Facilities for parallelism:
what should be in a parallel library . . 20--22
Alan Creak How things were: Programming lessons
from days gone by: backward ran
sentences until reeled the mind . . . . 23--26
Prabhat K. Singh and
Arun Lakhotia Analysis and detection of computer
viruses and worms: an annotated
bibliography . . . . . . . . . . . . . . 29--35
Awais Rashid Weaving aspects in a persistent
environment . . . . . . . . . . . . . . 36--44
Bernd Kühl and
Axel-Tobias Schreiner Objects for lexical analysis . . . . . . 45--52
Robert M. Siegfried A scripting language to help the blind
to program visually . . . . . . . . . . 53--56
Nadia Nedjah and
Luiza de Macedo Mourelle Efficient concise deterministic
pattern-matching automata for ambiguous
patterns . . . . . . . . . . . . . . . . 57--67
Qiu Zongyan Bit-vector encoding of $n$-queen problem 68--70
Craig Chambers Staged compilation (invited talk) . . . 1--8
Anne-Françoise Le Meur and
Julia L. Lawall and
Charles Consel Towards bridging the gap between
programming languages and partial
evaluation . . . . . . . . . . . . . . . 9--18
Kenichi Asai Online partial evaluation for shift and
reset . . . . . . . . . . . . . . . . . 19--30
Claus Brabrand and
Michael I. Schwartzbach Growing languages with metamorphic
syntax macros . . . . . . . . . . . . . 31--40
Jens Peter Secher and
Morten Heine Sòrensen From checking to inference via driving
and dag grammars . . . . . . . . . . . . 41--51
Germán Vidal Cost-augmented narrowing-driven
specialization . . . . . . . . . . . . . 52--62
Lunjin Lu Path dependent analysis of logic
programs . . . . . . . . . . . . . . . . 63--74
Gustavo Gómez and
Yanhong A. Liu Automatic time-bound analysis for a
higher-order language . . . . . . . . . 75--86
Roberto Giacobazzi and
Isabella Mastroeni Compositionality in the puzzle of
semantics . . . . . . . . . . . . . . . 87--97
Christian H. Bischof and
Paul D. Hovland and
Boyana Norris Implementation of automatic
differentiation tools (invited talk) . . 98--107
Yanhong A. Liu and
Scott D. Stoller Program optimization using indexed and
recursive data structures . . . . . . . 108--118
Naren Ramakrishnan and
Robert Capra and
Manuel A. Pérez-Quiñones Mixed-initiative interaction = mixed
computation . . . . . . . . . . . . . . 119--130
Gilles Barthe and
Tarmo Uustalu CPS translating inductive and
coinductive types . . . . . . . . . . . 131--142
Normal Ramsey \LaTeX Support for Proceedings . . . . . 1--3
Ron Cytron SIGPLAN Awards: The 2001 Award Winners 4--4
Jay Fenwick Conference Corner: Calendar . . . . . . 5--14
Anonymous Call for Participation: First
International IFIP/ACM Working
Conference on Component Deployment, June
20--21, 2002, Berlin Germany . . . . . . 15--15
Anonymous Call for Participation: ISSTA 2002:
International Symposium on Software
Testing and Analysis . . . . . . . . . . 16--16
Paul Frenger Forth Report: Strap-On Forth . . . . . . 17--20
Alan Creak How things were: Programming lessons
from days gone by: Cobol, stewed for
students . . . . . . . . . . . . . . . . 21--26
Thomas W. Christopher In Parallel: Communicating Reactive
Objects: Message-Driven Parallelism . . 27--28
Jay Fenwick and
Cindy Norris Information for Authors . . . . . . . . 29--29
Jay Fenwick and
Cindy Norris Information for Past Authors . . . . . . 30--30
Conrad Weisert If your only tool is a hammer,
everything looks like a nail: Pseudo
Object-Oriented Programming Considered
Harmful . . . . . . . . . . . . . . . . 31--31
Karen Zee and
Martin Rinard Write Barrier Removal by Static Analysis 32--41
Yumin Zhang and
Xiaobo (Sharon) Hu and
Danny Z. Chen Efficient Global Register Allocation for
Minimizing Energy Consumption . . . . . 42--53
Diomidis Spinellis A Modest Proposal for Curing the Public
Field Phobia . . . . . . . . . . . . . . 54--56
Pascal Ledru Smart Proxies for Jini Services . . . . 57--61
César F. Acebal and
Raúl Izquierdo Castanedo and
Juan M. Cueva Lovelle Good Design Principles in a Compiler
University Course . . . . . . . . . . . 62--73
Paul Damian Wells The HSSM macro-architecture, Virtual
Machine and H languages . . . . . . . . 74--82
Jeffrey S. Foster and
Tachio Terauchi and
Alex Aiken Flow-sensitive type qualifiers . . . . . 1--12
Manuel Fahndrich and
Robert DeLine Adoption and focus: practical linear
types for imperative programming . . . . 13--24
Zoran Budimlic and
Keith D. Cooper and
Timothy J. Harvey and
Ken Kennedy and
Timothy S. Oberg and
Steven W. Reeves Fast copy coalescing and live-range
identification . . . . . . . . . . . . . 25--32
Akira Koseki and
Hideaki Komatsu and
Toshio Nakatani Preference-directed graph coloring . . . 33--44
Karthik Gargi A sparse algorithm for predicated global
value numbering . . . . . . . . . . . . 45--56
Manuvir Das and
Sorin Lerner and
Mark Seigle ESP: path-sensitive program verification
in polynomial time . . . . . . . . . . . 57--68
Seth Hallem and
Benjamin Chelf and
Yichen Xie and
Dawson Engler A system and language for building
system-specific, static analyses . . . . 69--82
G. Ramalingam and
Alex Warshavsky and
John Field and
Deepak Goyal and
Mooly Sagiv Deriving specialized program analyses
for certifying component-client
conformance . . . . . . . . . . . . . . 83--94
Saumya Debray and
William Evans Profile-guided code compression . . . . 95--105
Mohan Rajagopalan and
Saumya K. Debray and
Matti A. Hiltunen and
Richard D. Schlichting Profile-directed optimization of
event-based programs . . . . . . . . . . 106--116
Steve S. W. Liao and
Perry H. Wang and
Hong Wang and
Gerolf Hoflehner and
Daniel Lavery and
John P. Shen Post-pass binary adaptation for
software-based speculative
precomputation . . . . . . . . . . . . . 117--128
Yoav Ossia and
Ori Ben-Yitzhak and
Irit Goft and
Elliot K. Kolodner and
Victor Leikehman and
Avi Owshanko A parallel, incremental and concurrent
GC for servers . . . . . . . . . . . . . 129--140
Niels Hallenberg and
Martin Elsman and
Mads Tofte Combining region inference and garbage
collection . . . . . . . . . . . . . . . 141--152
Stephen M. Blackburn and
Richard Jones and
Kathryn S. McKinley and
J. Eliot B. Moss Beltway: getting around garbage
collection gridlock . . . . . . . . . . 153--164
Byoungro So and
Mary W. Hall and
Pedro C. Diniz A compiler approach to fast hardware
design space exploration in FPGA-based
systems . . . . . . . . . . . . . . . . 165--176
Daniel Cociorva and
Gerald Baumgartner and
Chi-Chung Lam and
P. Sadayappan and
J. Ramanujam and
Marcel Nooijen and
David E. Bernholdt and
Robert Harrison Space-time trade-off optimization for a
class of electronic structure
calculations . . . . . . . . . . . . . . 177--186
Motohiro Kawahito and
Hideaki Komatsu and
Toshio Nakatani Effective sign extension elimination . . 187--198
Trishul M. Chilimbi and
Martin Hirzel Dynamic hot data stream prefetching for
general-purpose programs . . . . . . . . 199--209
Youfeng Wu Efficient discovery of regular stride
patterns in irregular programs and its
use in compiler prefetching . . . . . . 210--221
Martin Burtscher and
Amer Diwan and
Matthias Hauswirth Static load classification for improving
the value predictability of data-cache
misses . . . . . . . . . . . . . . . . . 222--233
Cormac Flanagan and
K. Rustan M. Leino and
Mark Lillibridge and
Greg Nelson and
James B. Saxe and
Raymie Stata Extended static checking for Java . . . 234--245
K. Rustan M. Leino and
Arnd Poetzsch-Heffter and
Yunhong Zhou Using data groups to specify and check
side effects . . . . . . . . . . . . . . 246--257
Jong-Deok Choi and
Keunwoo Lee and
Alexey Loginov and
Robert O'Callahan and
Vivek Sarkar and
Manu Sridharan Efficient and precise datarace detection
for multithreaded object-oriented
programs . . . . . . . . . . . . . . . . 258--269
Jason Baker and
Wilson C. Hsieh Maya: multiple-dispatch syntax extension
in Java . . . . . . . . . . . . . . . . 270--281
Dan Grossman and
Greg Morrisett and
Trevor Jim and
Michael Hicks and
Yanling Wang and
James Cheney Region-based memory management in
cyclone . . . . . . . . . . . . . . . . 282--293
George Almási and
David Padua MaJIC: compiling MATLAB for speed and
responsiveness . . . . . . . . . . . . . 294--303
Rajeev Joshi and
Greg Nelson and
Keith Randall Denali: a goal-directed superoptimizer 304--314
Thomas A. Henzinger and
Christoph M. Kirsch The embedded machine: predictable,
portable real-time code . . . . . . . . 315--326
Paul Frenger Forth report: Forth's DOOM . . . . . . . 14--17
Joseph Bergin and
Russel Winder Understanding object-oriented
programming . . . . . . . . . . . . . . 18--25
Jay Fenwick and
Cindy Norris Information for Authors . . . . . . . . 26--26
Jay Fenwick and
Cindy Norris Information for Past Authors . . . . . . 27--27
Haiming Chen and
Yunmei Dong Yet another meta-language for
programming language processing . . . . 28--37
Dai Guilan and
Tian Jinlan and
Zhang Suqin and
Jiang Weidu and
Dai Jun Retargetable cross compilation
techniques: comparison and analysis of
GCC and Zephyr . . . . . . . . . . . . . 38--44
Dai Guilan and
Zhang Suqing and
Tian Jinlan and
Jiang Weidu A study of compiler techniques for
multiple targets in compiler
infrastructures . . . . . . . . . . . . 45--51
Oleg Kiselyov SXML specification . . . . . . . . . . . 52--58
Paul Cockshott Vector Pascal reference manual . . . . . 59--81
Ji-Hyun Lee and
Cheol-Jung Yoo and
Ok-Bae Chang Analysis of object interaction during
the enterprise JavaBeans lifecycle using
formal specification technique . . . . . 82--92
Philippe Magarshack Systems-on-chip needs for embedded
software development: an industrial
perspective . . . . . . . . . . . . . . 1--1
H. Saputra and
M. Kandemir and
N. Vijaykrishnan and
M. J. Irwin and
J. S. Hu and
C-H. Hsu and
U. Kremer Energy-conscious compilation based on
voltage scaling . . . . . . . . . . . . 2--11
Hyunok Oh and
Soonhoi Ha Fractional rate dataflow model and
efficient code synthesis for multimedia
applications . . . . . . . . . . . . . . 12--17
S. Mohanty and
V. K. Prasanna and
S. Neema and
J. Davis Rapid design space exploration of
heterogeneous embedded systems using
symbolic search and multi-granular
simulation . . . . . . . . . . . . . . . 18--27
Krishna V. Palem and
Rodric M. Rabbah and
Vincent J. Mooney and
III and
Pinar Korkmaz and
Kiran Puttaswamy Design space optimization of embedded
memory systems via data remapping . . . 28--37
Frank Hunleth and
Ron K. Cytron Footprint and feature management using
aspect-oriented programming techniques 38--45
Daniel Kästner and
Stephan Wilhelm Generic control flow reconstruction from
assembly code . . . . . . . . . . . . . 46--55
Arvind Krishnaswamy and
Rajiv Gupta Profile guided selection of ARM and
thumb instructions . . . . . . . . . . . 56--64
Takayuki Wakabayashi and
Hiroaki Takada Standardization approach of ITRON
debugging interface specification and
evaluation of its adaptability . . . . . 65--74
Arshad Jhumka and
Martin Hiller and
Vilgot Claesson and
Neeraj Suri On systematic design of globally
consistent executable assertions in
embedded software . . . . . . . . . . . 75--84
Xiushan Feng and
Alan J. Hu Automatic formal verification for
scheduled VLIW code . . . . . . . . . . 85--92
Gerhard Fettweis DSPs: why don't they just go away! . . . 93--93
Markus Lorenz and
Lars Wehmeyer and
Thorsten Dräger Energy aware compilation for DSPs with
SIMD instructions . . . . . . . . . . . 94--101
Christoph Kessler and
Andrzej Bednarski Optimal integrated code generation for
clustered VLIW architectures . . . . . . 102--111
Yi Qian and
Steve Carr and
Philip Sweany Loop fusion for clustered VLIW
architectures . . . . . . . . . . . . . 112--119
Mayur Naik and
Jens Palsberg Compiling with code-size constraints . . 120--129
Jeonghun Cho and
Yunheung Paek and
David Whalley Efficient register and memory assignment
for non-orthogonal architectures via
graph coloring and MST algorithms . . . 130--138
Bernhard Scholz and
Erik Eckstein Register allocation for irregular
architectures . . . . . . . . . . . . . 139--148
Volker Barthelmann Inter-task register-allocation for
static operating systems . . . . . . . . 149--154
Wankang Zhao and
Baosheng Cai and
David Whalley and
Mark W. Bailey and
Robert van Engelen and
Xin Yuan and
Jason D. Hiser and
Jack W. Davidson and
Kyle Gallivan and
Douglas L. Jones VISTA: a system for interactive code
improvement . . . . . . . . . . . . . . 155--164
J. S. Hu and
M. Kandemir and
N. Vijaykrishnan and
M. J. Irwin and
H. Saputra and
W. Zhang Compiler-directed cache polymorphism . . 165--174
Christopher W. Milner and
Jack W. Davidson Quick piping: a fast, high-level model
for describing processor pipelines . . . 175--184
Oliver Wahlen and
Tilman Glökler and
Achim Nohl and
Andreas Hoffmann and
Rainer Leupers and
Heinrich Meyr Application specific
compiler/architecture codesign: a case
study . . . . . . . . . . . . . . . . . 185--193
Jeffrey Palm and
Han Lee and
Amer Diwan and
J. Eliot B. Moss When to use a compilation service? . . . 194--203
Matt Newsome and
Des Watson Proxy compilation of dynamically loaded
Java classes with MoJo . . . . . . . . . 204--212
Ajay Dudani and
Frank Mueller and
Yifan Zhu Energy-conserving feedback EDF
scheduling for embedded systems with
real-time constraints . . . . . . . . . 213--222
Saehwa Kim and
Seongsoo Hong and
Tae-Hyung Kim Perfecting preemption threshold
scheduling for object-oriented real-time
system design: from the perspective of
real-time synchronization . . . . . . . 223--232
Paul Frenger Forth report: Quartus Forth for the Palm
Pilot . . . . . . . . . . . . . . . . . 6--8
Chris Clark Practical parsing patterns: Conflicts 9--14
Thomas W. Christopher In parallel: HPC is a strange land . . . 15--16
Jay Fenwick and
Cindy Norris Information for Authors . . . . . . . . 17--17
Jay Fenwick and
Cindy Norris Information for Past Authors . . . . . . 18--18
Elliott Hughes How many trivial getter methods does
Java have? . . . . . . . . . . . . . . . 19--24
Taewoong Jeon and
Hyon Woo Seung and
Sungyoung Lee Embedding built-in tests in hot spots of
an object-oriented framework . . . . . . 25--34
Francisco Ortín and
Juan Manuel Cueva Implementing a real
computational-environment jump in order
to develop a runtime-adaptable
reflective platform . . . . . . . . . . 35--44
Zhenqiang Chen and
Baowen Xu and
Jianjun Zhao An overview of methods for dependence
analysis of concurrent programs . . . . 45--52
Dhananjay M. Dhamdhere E-path\_PRE: partial redundancy
elimination made easy . . . . . . . . . 53--65
Kyung Goo Doh and
Seung Cheol Shin Detection of information leak by data
flow analysis . . . . . . . . . . . . . 66--71
Brad A. Myers Towards more natural functional
programming languages . . . . . . . . . 1--1
Ralf Hinze Bootstrapping one-sided flexible arrays 2--13
Janis Voigtländer Concatenate, reverse and map vanish for
free . . . . . . . . . . . . . . . . . . 14--25
Magnus Carlsson Monads for incremental computing . . . . 26--35
Bryan Ford Packrat parsing: simple, powerful, lazy,
linear time, functional pearl . . . . . 36--47
Robert Bruce Findler and
Matthias Felleisen Contracts for higher-order functions . . 48--59
Atsushi Ohori and
Kiyoshi Yamatodani An interoperable calculus for external
object access . . . . . . . . . . . . . 60--71
Matthew Flatt Composable and compilable macros: you
want it when? . . . . . . . . . . . . . 72--83
Danny Dubé and
Marc Feeley A demand-driven adaptive type analysis 84--97
Kevin Glynn and
Peter J. Stuckey and
Martin Sulzmann and
Harald Sòndergaard Exception analysis for non-strict
languages . . . . . . . . . . . . . . . 98--109
Todd Millstein and
Colin Bleckner and
Craig Chambers Modular typechecking for hierarchically
extensible datatypes and functions . . . 110--122
J. Strother Moore Functional formal methods . . . . . . . 123--123
Josef Svenningsson Shortcut fusion for accumulating
parameters & zip-like functions . . . . . 124--132
Christoph Lüth and
Neil Ghani Composing monads using coproducts . . . 133--144
Keith Hanna Interactive visual functional
programming . . . . . . . . . . . . . . 145--156
Arthur I. Baars and
S. Doaitse Swierstra Typing dynamic typing . . . . . . . . . 157--166
Peter J. Stuckey and
Martin Sulzmann A theory of overloading . . . . . . . . 167--178
Matthias Neubauer and
Peter Thiemann Type classes with more higher-order
polymorphism . . . . . . . . . . . . . . 179--190
Karl Crary and
Joseph C. Vanderwaart An expressive, scalable type theory for
certified code . . . . . . . . . . . . . 191--205
Aleksandar Nanevski Meta-programming with names and
necessity . . . . . . . . . . . . . . . 206--217
Emir Pa\vsali\'c and
Walid Taha and
Tim Sheard Tagless staged interpreters for typed
languages . . . . . . . . . . . . . . . 218--229
Olivier Danvy and
Mayer Goldberg There and back again . . . . . . . . . . 230--234
Benjamin Grégoire and
Xavier Leroy A compiled implementation of strong
reduction . . . . . . . . . . . . . . . 235--246
Lars T. Hansen and
William D. Clinger An experimental study of
renewal-older-first garbage collection 247--258
Bernard Paul Serpette and
Manuel Serrano Compiling scheme to JVM bytecode: a
performance study . . . . . . . . . . . 259--270
Martin Gasbichler and
Michael Sperber Final shift for call/cc: direct
implementation of shift and reset . . . 271--282
Neil D. Jones and
Arne J. Glenstrup Program generation, termination, and
binding-time analysis . . . . . . . . . 283--283
Deborah Estrin Sensor Network Research: Emerging
Challenges for Architecture, Systems,
and Languages . . . . . . . . . . . . . 1--1
Ravi Rajwar and
James R. Goodman Transactional lock-free execution of
lock-based programs . . . . . . . . . . 5--17
José F. Martínez and
Josep Torrellas Speculative synchronization: applying
thread-level speculation to explicitly
parallel applications . . . . . . . . . 18--29
Kevin M. Lepak and
Mikko H. Lipasti Temporally silent stores . . . . . . . . 30--41
Timothy Sherwood and
Erez Perelman and
Greg Hamerly and
Brad Calder Automatically characterizing large scale
program behavior . . . . . . . . . . . . 45--57
Kazunori Ogata and
Hideaki Komatsu and
Toshio Nakatani Bytecode fetch optimization for a Java
interpreter . . . . . . . . . . . . . . 58--67
Tao Li and
Lizy Kurian John and
Anand Sivasubramaniam and
N. Vijaykrishnan and
Juan Rubio Understanding and improving operating
system effects in control flow
prediction . . . . . . . . . . . . . . . 68--80
Philip Levis and
David Culler Maté: a tiny virtual machine for sensor
networks . . . . . . . . . . . . . . . . 85--95
Philo Juang and
Hidekazu Oki and
Yong Wang and
Margaret Martonosi and
Li Shiuan Peh and
Daniel Rubenstein Energy-efficient computing for wildlife
tracking: design tradeoffs and early
experiences with ZebraNet . . . . . . . 96--107
Darko Kirovski and
Milenko Drini\'c and
Miodrag Potkonjak Enabling trusted software integrity . . 108--120
Heng Zeng and
Carla S. Ellis and
Alvin R. Lebeck and
Amin Vahdat ECOSystem: managing energy as a first
class operating system resource . . . . 123--132
Raksit Ashok and
Saurabh Chheda and
Csaba Andras Moritz Cool-Mem: combining statically
speculative memory accessing with
selective address translation for energy
efficiency . . . . . . . . . . . . . . . 133--143
Ruchira Sasanka and
Christopher J. Hughes and
Sarita V. Adve Joint local and global hardware
adaptations for energy . . . . . . . . . 144--155
Dongkeun Kim and
Donald Yeung Design and evaluation of compiler
algorithms for pre-execution . . . . . . 159--170
Antonia Zhai and
Christopher B. Colohan and
J. Gregory Steffan and
Todd C. Mowry Compiler optimization of scalar value
communication between speculative
threads . . . . . . . . . . . . . . . . 171--183
Jeffrey Oplinger and
Monica S. Lam Enhancing software reliability with
speculative threads . . . . . . . . . . 184--196
J. Adam Butts and
Guri Sohi Dynamic dead-instruction detection and
elimination . . . . . . . . . . . . . . 199--210
Changkyu Kim and
Doug Burger and
Stephen W. Keckler An adaptive, non-uniform cache structure
for wire-delay dominated on-chip caches 211--222
Shubhendu S. Mukherjee and
Federico Silla and
Peter Bannon and
Joel Emer and
Steve Lang and
David Webb A comparative study of arbitration
algorithms for the Alpha 21364 pipelined
router . . . . . . . . . . . . . . . . . 223--234
Hyong-youb Kim and
Vijay S. Pai and
Scott Rixner Increasing Web server throughput with
network interface data caching . . . . . 239--250
Eddie Kohler and
Robert Morris and
Benjie Chen Programming language optimizations for
modular router configurations . . . . . 251--263
Muthian Sivathanu and
Andrea C. Arpaci-Dusseau and
Remzi H. Arpaci-Dusseau Evolving RPC for active storage . . . . 264--276
Robert Cooksey and
Stephan Jourdan and
Dirk Grunwald A stateless, content-directed data
prefetching mechanism . . . . . . . . . 279--290
Michael I. Gordon and
William Thies and
Michal Karczmarek and
Jasper Lin and
Ali S. Meli and
Andrew A. Lamb and
Chris Leger and
Jeremy Wong and
Henry Hoffmann and
David Maze and
Saman Amarasinghe A stream compiler for
communication-exposed architectures . . 291--303
Emmett Witchel and
Josh Cates and
Krste Asanovi\'c Mondrian memory protection . . . . . . . 304--316
Emery D. Berger and
Benjamin G. Zorn and
Kathryn S. McKinley Reconsidering custom memory allocation 1--12
Yefim Shuf and
Manish Gupta and
Hubertus Franke and
Andrew Appel and
Jaswinder Pal Singh Creating and preserving locality of Java
applications at allocation and garbage
collection times . . . . . . . . . . . . 13--25
Magnus E. Bjornsson and
Liuba Shrira BuddyCache: high-performance object
storage for collaborative
strong-consistency applications in a WAN 26--39
Dragos A. Manolescu Workflow enactment with continuation and
future objects . . . . . . . . . . . . . 40--51
Mira Mezini and
Klaus Ostermann Integrating independent components with
on-demand remodularization . . . . . . . 52--67
Marc-Olivier Killijian and
Juan-Carlos Ruiz and
Jean-Charles Fabre Portable serialization of CORBA objects:
a reflective approach . . . . . . . . . 68--82
Rami Marelly and
David Harel and
Hillel Kugler Multiple instances and symbolic
variables in executable sequence charts 83--100
Laurent Michel and
Pascal Van Hentenryck A constraint-based architecture for
local search . . . . . . . . . . . . . . 101--110
Matthew Arnold and
Michael Hind and
Barbara G. Ryder Online feedback-directed optimization of
Java . . . . . . . . . . . . . . . . . . 111--129
Kiyokuni Kawachiya and
Akira Koseki and
Tamiya Onodera Lock reservation: Java locks can mostly
do without atomic operations . . . . . . 130--141
Yoav Zibin and
Joseph Yossi Gil Fast algorithm for creating space
efficient dispatching tables with
application to multi-dispatching . . . . 142--160
Jan Hannemann and
Gregor Kiczales Design pattern implementation in Java
and aspectJ . . . . . . . . . . . . . . 161--173
Sergio Soares and
Eduardo Laureano and
Paulo Borba Implementing distribution and
persistence aspects with aspectJ . . . . 174--190
Karen Zee and
Martin Rinard Write barrier removal by static analysis 191--210
Chandrasekhar Boyapati and
Robert Lee and
Martin Rinard Ownership types for safe programming:
preventing data races and deadlocks . . 211--230
Sarfraz Khurshid and
Darko Marinov and
Daniel Jackson An analyzable annotation language . . . 231--245
Emmanuel Cecchet and
Julie Marguerite and
Willy Zwaenepoel Performance and scalability of EJB
applications . . . . . . . . . . . . . . 246--261
Krzysztof Palacz and
Jan Vitek and
Grzegorz Czajkowski and
Laurent Daynas Incommunicado: efficient communication
for isolates . . . . . . . . . . . . . . 262--274
Bjorn De Sutter and
Bruno De Bus and
Koen De Bosschere Sifting out the mud: low level C++ code
reuse . . . . . . . . . . . . . . . . . 275--291
Dave Clarke and
Sophia Drossopoulou Ownership, encapsulation and the
disjointness of type and effect . . . . 292--310
Jonathan Aldrich and
Valentin Kostadinov and
Craig Chambers Alias annotations for program
understanding . . . . . . . . . . . . . 311--330
Riccardo Pucella Towards a formalization for COM. Part I:
The primitive calculus . . . . . . . . . 331--342
Tony Printezis and
Richard Jones GCspy: an adaptable heap visualisation
framework . . . . . . . . . . . . . . . 343--358
Larry Koved and
Marco Pistoia and
Aaron Kershenbaum Access rights analysis for Java . . . . 359--372
Mikhail Dmitriev Language-specific make technology for
the Java programming language . . . . . 373--385
Paul Frenger Forth report: Going APE.FORTH to Mars 9--13
Alan Creak How things were: Edsger W. Dijkstra . . 14--16
Cindy Norris Introduction to special issue . . . . . 17--17
Thomas Arts and
Lars-Åke Fredlund Trace analysis of Erlang programs . . . 18--24
Ulf Wiger and
Gösta Ask and
Kent Boortz World-class product certification using
Erlang . . . . . . . . . . . . . . . . . 25--34
Koen Claessen and
Gordon J. Pace An embedded language approach to
teaching hardware compilation . . . . . 35--46
Koen Claessen and
John Hughes Testing monadic code with QuickCheck . . 47--59
Tim Sheard and
Simon Peyton Jones Template meta-programming for Haskell 60--75
Jean-Louis Giavitto and
Olivier Michel and
Julien Cohen Pattern-matching and rewriting rules for
group indexed data structures . . . . . 76--87
Martin Erwig and
Delin Ren A rule-based language for programming
software updates . . . . . . . . . . . . 88--97
Jan Friso Groote and
Bert Lisser Computer assisted manipulation of
algebraic process specifications . . . . 98--107
Miguel J. Hornos and
Manuel I. Capel On-the-fly model checking from interval
logic specifications . . . . . . . . . . 108--119
Jérôme Siméon and
Philip Wadler The essence of XML . . . . . . . . . . . 1--13
Umut A. A. Acar and
Guy E. Blelloch and
Robert Harper Selective memoization . . . . . . . . . 14--25
Walid Taha and
Michael Florentin Nielsen Environment classifiers . . . . . . . . 26--37
Ole Hògh Jensen and
Robin Milner Bigraphs and transitions . . . . . . . . 38--49
Alan Schmitt and
Jean-Bernard Stefani The $m$-calculus: a higher-order
distributed process calculus . . . . . . 50--61
Ahmed Bouajjani and
Javier Esparza and
Tayssir Touili A generic approach to the static
analysis of concurrent programs with
procedures . . . . . . . . . . . . . . . 62--73
Sumit Gulwani and
George C. Necula Discovering affine equalities using
random interpretation . . . . . . . . . 74--84
Sriraman Tallam and
Rajiv Gupta Bitwidth aware global register
allocation . . . . . . . . . . . . . . . 85--96
Thomas Ball and
Mayur Naik and
Sriram K. Rajamani From symptom to cause: localizing errors
in counterexample traces . . . . . . . . 97--105
Larry Carter and
Jeanne Ferrante and
Clark Thomborson Folklore confirmed: reducible flow
graphs are exponentially larger . . . . 106--114
Venkatesan T. Chakaravarthy New results on the computability and
complexity of points--to analysis . . . 115--125
Yoav Zibin and
Joseph (Yossi) Gil Incremental algorithms for dispatching
in dynamically typed languages . . . . . 126--138
Hayo Thielecke From control effects to typed
continuation passing . . . . . . . . . . 139--149
Gang Chen Coercive subtyping for the calculus of
constructions . . . . . . . . . . . . . 150--159
Yoav Zibin and
Joseph (Yossi) Gil and
Jeffrey Considine Efficient algorithms for isomorphisms of
simple types . . . . . . . . . . . . . . 160--171
Leaf Petersen and
Robert Harper and
Karl Crary and
Frank Pfenning A type theory for memory allocation and
data layout . . . . . . . . . . . . . . 172--184
Martin Hofmann and
Steffen Jost Static prediction of heap space usage
for first-order functional programs . . 185--197
Karl Crary Toward a foundational typed assembly
language . . . . . . . . . . . . . . . . 198--212
Chandrasekhar Boyapati and
Barbara Liskov and
Liuba Shrira Ownership types for object encapsulation 213--223
Hongwei Xi and
Chiyan Chen and
Gang Chen Guarded recursive datatype constructors 224--235
Derek Dreyer and
Karl Crary and
Robert Harper A type system for higher-order modules 236--249
Gilles Barthe and
Horatiu Cirstea and
Claude Kirchner and
Luigi Liquori Pure patterns type systems . . . . . . . 250--261
Hans-J. Boehm Destructors, finalizers, and
synchronization . . . . . . . . . . . . 262--272
Ovidiu Gheorghioiu and
Alexandru Salcianu and
Martin Rinard Interprocedural compatibility analysis
for static object preallocation . . . . 273--284
David F. Bacon and
Perry Cheng and
V. T. Rajan A real-time garbage collector with low
overhead and consistent utilization . . 285--298
Chen Ding and
Yutao Zhong Compiler-directed run-time monitoring of
program data access . . . . . . . . . . 1--12
Dai Guilan and
Tian Jinlan and
Zhang Suqing and
Jiang Weidu An abstract intermediate representation
in compilation systems . . . . . . . . . 12--18
Chris Lattner and
Vikram Adve Automatic pool allocation for disjoint
data structures . . . . . . . . . . . . 13--24
Jennifer Hamilton Language integration in the common
language runtime . . . . . . . . . . . . 19--28
Darko Stefanovi\'c and
Matthew Hertz and
Stephen M. Blackburn and
Kathryn S. McKinley and
J. Eliot B. Moss Older-first garbage collection in
practice: evaluation in a Java Virtual
Machine . . . . . . . . . . . . . . . . 25--36
Quinn Tyler Jackson Efficient formalism-only parsing of
XML/HTML using the \S-calculus . . . . . 29--35
Jonathan L. Schilling The simplest heuristics may be the best
in Java JIT compilers . . . . . . . . . 36--46
George Almási and
C\ualin Ca\cscaval and
David A. Padua Calculating stack distances efficiently 37--43
Nicholas Nethercote and
Alan Mycroft The cache behaviour of large lazy
functional programs on stock hardware 44--55
Robert Sinclair Interactive mathematics textbooks . . . 47--56
Ricardo Lopes and
Luís Fernando Castro and
Vítor Santos Costa From simulation to practice: cache
performance study of a Prolog system . . 56--64
Christian Queinnec Inverting back the inversion of control
or, continuations versus page-centric
programming . . . . . . . . . . . . . . 57--64
Ch. Ykman-Couvreur and
J. Lambrecht and
A. van der Togt and
F. Catthoor Multi-objective abstract data type
refinement for mapping tables in
telecom network applications . . . . . . 65--75
Martin Schulz and
Jie Tao and
Jürgen Jeitner and
Wolfgang Karl A proposal for a new hardware cache
monitoring architecture . . . . . . . . 76--85
Nihar R. Mahapatra and
Jiangjiang Liu and
Krishnan Sundaresan The performance advantage of applying
compression to the memory system . . . . 86--96
Keith D. Cooper and
Li Xu An efficient static analysis algorithm
to detect redundant memory operations 97--107
Sven G. Robertz Applying priorities to memory allocation 108--118
Toshio Endo and
Kenjiro Taura Reducing pause time of conservative
collectors . . . . . . . . . . . . . . . 119--131
Morgan Deters and
Ron K. Cytron Automated discovery of scoped memory
regions for real-time Java . . . . . . . 132--142
Martin Hirzel and
Johannes Henkel and
Amer Diwan and
Michael Hind Understanding the connectivity of heap
objects . . . . . . . . . . . . . . . . 143--156
Tony Printezis and
Alex Garthwaite Visualising the train garbage collector 157--170
Ran Shaham and
Elliot K. Kolodner and
Mooly Sagiv Estimating the impact of heap liveness
information on space consumption in Java 171--182
Tamar Domani and
Gal Goldshtein and
Elliot K. Kolodner and
Ethan Lewis and
Erez Petrank and
Dafna Sheinwald Thread-local heaps for Java . . . . . . 183--194
Erik Johansson and
Konstantinos Sagonas and
Jesper Wilhelmsson Heap architectures for concurrent
languages using message passing . . . . 195--206
Ori Ben-Yitzhak and
Irit Goft and
Elliot K. Kolodner and
Kean Kuiper and
Victor Leikehman An algorithm for parallel incremental
compaction . . . . . . . . . . . . . . . 207--212
Abhay Vardhan and
Gul Agha Using passive object garbage collection
algorithms for garbage collection of
active objects . . . . . . . . . . . . . 213--220
Scott F. Kaplan and
Lyle A. McGeoch and
Megan F. Cole Adaptive caching for demand prepaging 221--232
Feng Qian and
Laurie Hendren An adaptive, region-based allocator for
Java . . . . . . . . . . . . . . . . . . 233--244
Sanjeev Kumar and
Kai Li Dynamic memory management for
programmable devices . . . . . . . . . . 245--255
Fergus Henderson Accurate garbage collection in an
uncooperative environment . . . . . . . 256--262
Aneesh Aggarwal Software caching vs. prefetching . . . . 263--268
Dave Dice and
Alex Garthwaite Mostly lock-free malloc . . . . . . . . 269--280
Stephen M. Blackburn and
Kathryn S. McKinley In or out?: putting write barriers in
their place . . . . . . . . . . . . . . 281--290
Cormac Flanagan and
Shaz Qadeer Types for atomicity . . . . . . . . . . 1--12
Dan Grossman Type-safe multithreading in cyclone . . 13--25
Ralf Lämmel and
Simon Peyton Jones Scrap your boilerplate: a practical
design pattern for generic programming 26--37
Sungwoo Park A calculus for probabilistic languages 38--49
Naoki Kobayashi Time regions and effects for resource
usage analysis . . . . . . . . . . . . . 50--61
Cristiano Calcagno and
Luca Cardelli and
Andrew D. Gordon Deciding validity in a spatial logic for
trees . . . . . . . . . . . . . . . . . 62--73
Amal Ahmed and
David Walker The logical approach to stack typing . . 74--85
Torben Amtoft and
Robert Muller Inferring annotated types for
inter-procedural register allocation
with constructor flattening . . . . . . 86--97
Joseph C. Vanderwaart and
Derek Dreyer and
Leaf Petersen and
Karl Crary and
Robert Harper and
Perry Cheng Typed compilation of recursive datatypes 98--108
Joseph C. Vanderwaart and
Karl Crary A typed interface for garbage collection 109--122
Martin Elsman Garbage collection safety for
region-based memory management . . . . . 123--134
Alan Creak Everything is Fortran, in its own way 7--12
Paul Frenger Evaluating Forth in the Windows
environment . . . . . . . . . . . . . . 13--15
Dibyendu Das Function inlining versus function
cloning . . . . . . . . . . . . . . . . 18--24
José de Oliveira Guimarães Experiences in building a compiler for
an object-oriented language . . . . . . 25--33
Jagun Kwon and
Andy Wellings and
Steve King Assessment of the Java programming
language for use in high integrity
systems . . . . . . . . . . . . . . . . 34--46
Lei Luo and
Ming-Yuan Zhu and
Qing-Li Zhang A formal semantic definition of DEVIL 47--56
Hai Zhuge and
Jie Liu KGOL: a Knowledge Grid operating
language . . . . . . . . . . . . . . . . 57--66
David Gay and
Philip Levis and
Robert von Behren and
Matt Welsh and
Eric Brewer and
David Culler The \em nesC language: A holistic
approach to networked embedded systems 1--11
Andrew A. Lamb and
William Thies and
Saman Amarasinghe Linear analysis and optimization of
stream programs . . . . . . . . . . . . 12--25
Lal George and
Matthias Blume Taming the IXP network processor . . . . 26--37
Chung-Hsing Hsu and
Ulrich Kremer The design, implementation, and
evaluation of a compiler algorithm for
CPU energy reduction . . . . . . . . . . 38--48
Fen Xie and
Margaret Martonosi and
Sharad Malik Compile-time dynamic voltage scaling
settings: opportunities and limits . . . 49--62
Kamen Yotov and
Xiaoming Li and
Gang Ren and
Michael Cibulskis and
Gerald DeJong and
Maria Garzaran and
David Padua and
Keshav Pingali and
Paul Stodghill and
Peng Wu A comparison of empirical and
model-driven optimization . . . . . . . 63--76
Mark Stephenson and
Saman Amarasinghe and
Martin Martin and
Una-May O'Reilly Meta optimization: improving compiler
heuristics with machine learning . . . . 77--90
Michelle Mills Strout and
Larry Carter and
Jeanne Ferrante Compile-time composition of run-time
data and iteration reorderings . . . . . 91--102
Marc Berndl and
Ondrej Lhoták and
Feng Qian and
Laurie Hendren and
Navindra Umanee Points-to analysis using BDDs . . . . . 103--114
Christoph von Praun and
Thomas R. Gross Static conflict analysis for
multi-threaded object-oriented programs 115--128
Alex Aiken and
Jeffrey S. Foster and
John Kodumal and
Tachio Terauchi Checking and inferring local
non-aliasing . . . . . . . . . . . . . . 129--140
Ben Liblit and
Alex Aiken and
Alice X. Zheng and
Michael I. Jordan Bug isolation via remote program
sampling . . . . . . . . . . . . . . . . 141--154
Nurit Dor and
Michael Rodeh and
Mooly Sagiv CSSV: towards a realistic tool for
statically detecting all buffer
overflows in C . . . . . . . . . . . . . 155--167
David L. Heine and
Monica S. Lam A practical flow-sensitive and
context-sensitive C and C++ memory leak
detector . . . . . . . . . . . . . . . . 168--181
Glenn Ammons and
David Mandelin and
Rastislav Bodík and
James R. Larus Debugging temporal specifications with
concept analysis . . . . . . . . . . . . 182--195
Bruno Blanchet and
Patrick Cousot and
Radhia Cousot and
Jérome Feret and
Laurent Mauborgne and
Antoine Miné and
David Monniaux and
Xavier Rival A static analyzer for large
safety-critical software . . . . . . . . 196--207
Juan Chen and
Dinghao Wu and
Andrew W. Appel and
Hai Fang A provably sound TAL for back-end
optimization . . . . . . . . . . . . . . 208--219
Sorin Lerner and
Todd Millstein and
Craig Chambers Automatically proving the correctness of
compiler optimizations . . . . . . . . . 220--231
Jeremy Condit and
Matthew Harren and
Scott McPeak and
George C. Necula and
Westley Weimer CCured in the real world . . . . . . . . 232--244
Chen Ding and
Yutao Zhong Predicting whole-program locality
through reuse distance analysis . . . . 245--257
Pramod G. Joisha and
Prithviraj Banerjee Static array storage optimization in
MATLAB . . . . . . . . . . . . . . . . . 258--268
Tatsushi Inagaki and
Tamiya Onodera and
Hideaki Komatsu and
Toshio Nakatani Stride prefetching by dynamically
inspecting objects . . . . . . . . . . . 269--277
M. Anton Ertl and
David Gregg Optimizing indirect branch prediction
accuracy in virtual machine interpreters 278--288
Jin Lin and
Tong Chen and
Wei-Chung Hsu and
Pen-Chung Yew and
Roy Dz-Ching Ju and
Tin-Fook Ngai and
Sun Chan A compiler framework for speculative
analysis and optimizations . . . . . . . 289--299
Michael Chu and
Kevin Fan and
Scott Mahlke Region-based hierarchical operation
partitioning for multicluster processors 300--311
Toshio Suganuma and
Toshiaki Yasue and
Toshio Nakatani A region-based compilation technique for
a Java just-in-time compiler . . . . . . 312--323
Chandrasekhar Boyapati and
Alexandru Salcianu and
William Beebee, Jr. and
Martin Rinard Ownership types for safe region-based
memory management in real-time Java . . 324--337
Cormac Flanagan and
Shaz Qadeer A type and effect system for atomicity 338--349
Thomas W. Christopher A simple parallel system . . . . . . . . 6--8
Joe Bergin and
Achla Agarwal and
Krishna Agarwal Some deficiencies of C++ in teaching CS1
and CS2 . . . . . . . . . . . . . . . . 9--13
Barbara G. Ryder and
Mary Lou Soffa Influences on the design of exception
handling: ACM SIGSOFT project on the
impact of software engineering research
on programming language design . . . . . 16--22
Dibyendu Das Function inlining versus function
cloning . . . . . . . . . . . . . . . . 23--29
Yu ChunYan and
Wu Minghui and
Liu Nairuo and
Zhuang Yueting and
Pan Yunhe Translating EXPRESS language model into
C language model . . . . . . . . . . . . 30--39
Francisco Ortin and
Juan Manuel Cueva and
Ana Belen Martinez The reflective nitrO abstract machine 40--49
Boris Sunik The paradigm of open C++ . . . . . . . . 50--59
Qing-Li Zhang and
Ming-Yuan Zhu and
Shuo-Ying Chen Automatic generation of device drivers 60--69
Min Zhao and
Bruce Childers and
Mary Lou Soffa Predicting the impact of optimizations
for embedded systems . . . . . . . . . . 1--11
Prasad Kulkarni and
Wankang Zhao and
Hwashin Moon and
Kyunghwan Cho and
David Whalley and
Jack Davidson and
Mark Bailey and
Yunheung Paek and
Kyle Gallivan Finding effective optimization phase
sequences . . . . . . . . . . . . . . . 12--23
Peter Vanbroekhoven and
Gerda Janssens and
Maurice Bruynooghe and
Henk Corporaal and
Francky Catthoor Advanced copy propagation for arrays . . 24--33
Nik Shaylor and
Douglas N. Simon and
William R. Bush A Java Virtual Machine architecture for
very small devices . . . . . . . . . . . 34--41
Ulrik Pagh Schultz and
Kim Burgaard and
Flemming Gram Christensen and
Jòrgen Lindskov Knudsen Compiling Java for low-end embedded
systems . . . . . . . . . . . . . . . . 42--50
Angelo Corsaro and
Ron K. Cytron Efficient memory-reference checks for
real-time Java . . . . . . . . . . . . . 51--58
C. Scott Ananian and
Martin Rinard Data size optimizations for Java
programs . . . . . . . . . . . . . . . . 59--68
Dinakar Dhurjati and
Sumant Kowshik and
Vikram Adve and
Chris Lattner Memory safety without runtime checks or
garbage collection . . . . . . . . . . . 69--80
David F. Bacon and
Perry Cheng and
V. T. Rajan Controlling fragmentation and space
consumption in the metronome, a
real-time garbage collector for Java . . 81--92
Sven Gestegard Robertz and
Roger Henriksson Time-triggered garbage collection:
robust and adaptive real-time GC
scheduling for embedded systems . . . . 93--102
Michal Karczmarek and
William Thies and
Saman Amarasinghe Phased scheduling of stream programs . . 103--112
Paul Pop and
Petru Eles and
Zebo Peng Schedulability-driven frame packing for
multi-cluster distributed embedded
systems . . . . . . . . . . . . . . . . 113--122
Y. Ait-Ameur and
G. Bel and
F. Boniol and
S. Pairault and
V. Wiels Robustness analysis of avionics embedded
systems . . . . . . . . . . . . . . . . 123--132
Dionisio de Niz and
Raj Rajkumar Time weaver: a software-through-models
framework for embedded real-time systems 133--143
Ravi Pratap M. and
Ron K. Cytron and
David Sharp and
Edward Pla Transport layer abstraction in event
channels for embedded systems . . . . . 144--152
Paul Caspi and
Adrian Curic and
Aude Maignan and
Christos Sofronis and
Stavros Tripakis and
Peter Niebert From Simulink to SCADE/lustre to TTA: a
layered approach for distributed
embedded applications . . . . . . . . . 153--162
Andrzej Wasowski On efficient program synthesis from
statecharts . . . . . . . . . . . . . . 163--170
Rajeev Alur and
Franjo Ivancic and
Jesung Kim and
Insup Lee and
Oleg Sokolsky Generating embedded software from
hierarchical hybrid models . . . . . . . 171--182
Jong-eun Lee and
Kiyoung Choi and
Nikil D. Dutt An algorithm for mapping loops onto
coarse-grained reconfigurable
architectures . . . . . . . . . . . . . 183--188
Dinesh C. Suresh and
Walid A. Najjar and
Frank Vahid and
Jason R. Villarreal and
Greg Stitt Profiling tools for hardware/software
partitioning of embedded applications 189--198
Yuanqing Guo and
Gerard J. M. Smit and
Hajo Broersma and
Paul M. Heysters A graph covering algorithm for a coarse
grain reconfigurable system . . . . . . 199--208
Tao Zhang and
Santosh Pande and
Antonio Valverde Tamper-resistant whole program
partitioning . . . . . . . . . . . . . . 209--219
Xiaotong Zhuang and
ChokSheak Lau and
Santosh Pande Storage assignment optimizations through
variable coalescence for embedded
processors . . . . . . . . . . . . . . . 220--231
Marc L. Corliss and
E. Christopher Lewis and
Amir Roth A DISE implementation of dynamic code
decompression . . . . . . . . . . . . . 232--243
Bjorn De Sutter and
Hans Vandierendonck and
Bruno De Bus and
Koen De Bosschere On the side-effects of code abstraction 244--253
Arvind Krishnaswamy Enhancing the performance of 16-bit code
using augmenting instructions . . . . . 254--264
Yang Yu and
Viktor K. Prasanna Energy-balanced task allocation for
collaborative processing in networked
embedded systems . . . . . . . . . . . . 265--274
H. S. Kim and
N. Vijaykrishnan and
M. Kandemir and
M. J. Irwin Adapting instruction level parallelism
for optimizing leakage in VLIW
architectures . . . . . . . . . . . . . 275--283
Nevine AbouGhazaleh and
Bruce Childers and
Daniel Mosse and
Rami Melhem and
Matthew Craven Energy management for real-time embedded
applications with compiler support . . . 284--293
Thomas W. Christopher Details on a simple parallel system . . 12--14
Paul Frenger The JOY of Forth . . . . . . . . . . . . 15--17
C. Pronk and
M. Schönhacker Formal definition of programming
language standards . . . . . . . . . . . 20--21
Baomin Xu and
Weimin Lian and
Qiang Gao Migration of enterprise JavaBeans with
ProActive Interposition Objects . . . . 22--28
Pascal Costanza Dynamically scoped functions as the
essence of AOP . . . . . . . . . . . . . 29--36
Alex Iliasov Templates-based portable just-in-time
compiler . . . . . . . . . . . . . . . . 37--43
Marjan Hericko and
Matjaz B. Juric and
Ivan Rozman and
Simon Beloglavec and
Ales Zivkovic Object serialization analysis and
comparison in Java and .NET . . . . . . 44--54
Kurt Stephens XVF: C++ introspection by extensible
visitation . . . . . . . . . . . . . . . 55--59
K. V. Seshu Kumar Value reuse optimization: reuse of
evaluated math library function calls
through compiler generated cache . . . . 60--66
Thomas Knight, Jr. Conservation of information:
applications in functional, reversible,
and quantum computing . . . . . . . . . 1--1
Bastiaan Heeren and
Jurriaan Hage and
S. Doaitse Swierstra Scripting the type inference process . . 3--13
Matthias Neubauer and
Peter Thiemann Discriminative sum types locate the
source of type errors . . . . . . . . . 15--26
Didier Le Botlan and
Didier Rémy ML$^{F}$: raising ML to the power of
system F . . . . . . . . . . . . . . . . 27--38
Vincent Simonet An extension of HM(X) with bounded
existential and universal data-types . . 39--50
Véronique Benzaken and
Giuseppe Castagna and
Alain Frisch CDuce: an XML-centric general-purpose
language . . . . . . . . . . . . . . . . 51--63
Michael Y. Levin Compiling regular patterns . . . . . . . 65--77
Rex L. Page Software is discrete mathematics . . . . 79--86
James J. Leifer and
Gilles Peskine and
Peter Sewell and
Keith Wansbrough Global abstraction-safe marshalling with
hash types . . . . . . . . . . . . . . . 87--98
Gavin Bierman and
Michael Hicks and
Peter Sewell and
Gareth Stoyle and
Keith Wansbrough Dynamic Rebinding for Marshalling and
Update, with Destruct-time $\lambda$ . . 99--110
Mizuhito Ogawa and
Zhenjiang Hu and
Isao Sasano Iterative-free program analysis . . . . 111--123
Harry G. Mairson From Hilbert space to Dilbert space:
context semantics as a language for
games and flow analysis . . . . . . . . 125--125
David Walker and
Steve Zdancewic and
Jay Ligatti A theory of aspects . . . . . . . . . . 127--139
Andres Löh and
Dave Clarke and
Johan Jeuring Dependency-style generic Haskell . . . . 141--152
Henrik Nilsson Functional automatic differentiation
with Dirac impulses . . . . . . . . . . 153--164
Simon Peyton Jones and
Alan Blackwell and
Margaret Burnett A user-centred approach to functions in
Excel . . . . . . . . . . . . . . . . . 165--176
Yukiyoshi Kameyama and
Masahito Hasegawa A sound and complete axiomatization of
delimited continuations . . . . . . . . 177--188
Philip Wadler Call-by-value is dual to call-by-name 189--201
Emmanuel Beffara and
Vincent Danos Disjunctive normal forms and local
exceptions . . . . . . . . . . . . . . . 203--211
Yitzhak Mandelbaum and
David Walker and
Robert Harper An effective theory of type refinements 213--225
Tomoyuki Higuchi and
Atsushi Ohori A static type system for JVM access
control . . . . . . . . . . . . . . . . 227--237
R. John M. Hughes and
S. Doaitse Swierstra Polish parsers, step by step . . . . . . 239--248
Geoffrey Washburn and
Stephanie Weirich Boxes go bananas: encoding higher-order
abstract syntax with parametric
polymorphism . . . . . . . . . . . . . . 249--262
Mark R. Shinwell and
Andrew M. Pitts and
Murdoch J. Gabbay FreshML: programming with binders made
simple . . . . . . . . . . . . . . . . . 263--274
Chiyan Chen and
Hongwei Xi Meta-programming through typeful code
representation . . . . . . . . . . . . . 275--286
Robert Ennals and
Simon Peyton Jones Optimistic evaluation: an adaptive
evaluation strategy for non-strict
programs . . . . . . . . . . . . . . . . 287--298
Mitchell Wand Understanding aspects: extended abstract 299--300
Baris Kazar High performance spatial data mining for
very large data-sets (citation only) . . 1--1
Diego Puppin Adapting convergent scheduling using
machine learning (citation only) . . . . 1--1
Manohar K. Prabhu and
Kunle Olukotun Using thread-level speculation to
simplify manual parallelization . . . . 1--12
Cristian Coarfa and
Yuri Dotsenko An emerging co-array Fortran compiler
(citation only) . . . . . . . . . . . . 2--2
Jeffrey M. Squyres A component architecture for LAM/MPI
(citation only) . . . . . . . . . . . . 2--2
Jaejin Lee The Pensieve Project: automatic
implementation of programming language
consistency models (citation only) . . . 3--3
Piotr Nienaltowski SCOOP It up! (citation only) . . . . . . 3--3
Marcelo Cintra and
Diego R. Llanos Toward efficient and robust software
speculative parallelization on
multiprocessors . . . . . . . . . . . . 13--24
Peng-Sheng Chen and
Ming-Yu Hung and
Yuan-Shin Hwang and
Roy Dz-Ching Ju and
Jenq Kuen Lee Compiler support for speculative
multithreading architecture with
probabilistic points-to analysis . . . . 25--36
Luke K. McDowell and
Susan J. Eggers and
Steven D. Gribble Improving server software support for
simultaneous multithreaded processors 37--48
Basilio B. Fraguela and
Jose Renau and
Paul Feautrier and
David Padua and
Josep Torrellas Programming the FlexRAM parallel
intelligent memory system . . . . . . . 49--60
Hyong-youb Kim and
Vijay S. Pai and
Scott Rixner Exploiting task-level concurrency in a
programmable network interface . . . . . 61--72
Collin McCurdy and
Charles Fischer User-controllable coherence for high
performance shared memory
multiprocessors . . . . . . . . . . . . 73--82
Greg Bronevetsky and
Daniel Marques and
Keshav Pingali and
Paul Stodghill Automated application-level
checkpointing of MPI programs . . . . . 84--94
Amit Karwande and
Xin Yuan and
David K. Lowenthal CC--MPI: a compiled communication
capable MPI prototype for Ethernet
switched clusters . . . . . . . . . . . 95--106
Ting Liu and
Margaret Martonosi Impala: a middleware system for managing
autonomic, parallel sensor systems . . . 107--118
Lingkun Chu and
Hong Tang and
Tao Yang and
Kai Shen Optimizing data aggregation for
cluster-based Internet services . . . . 119--130
DeQing Chen and
Chunqiang Tang and
Brandon Sanders and
Sandhya Dwarkadas and
Michael L. Scott Exploiting high-level coherence
information to optimize distributed
shared state . . . . . . . . . . . . . . 131--142
Jeremy D. Frens and
David S. Wise Factorization with Morton-ordered
quadtree matrices for memory re-use and
parallelism . . . . . . . . . . . . . . 144--154
Jeremy D. Frens and
David S. Wise QR factorization with Morton-ordered
quadtree matrices for memory re-use and
parallelism . . . . . . . . . . . . . . 144--154
Steven J. Deitz and
Bradford L. Chamberlain and
Sung-Eun Choi and
Lawrence Snyder The design and implementation of a
parallel array operator for the
arbitrary remapping of data . . . . . . 155--166
Robert O'Callahan and
Jong-Deok Choi Hybrid dynamic data race detection . . . 167--178
Eli Pozniansky and
Assaf Schuster Efficient on-the-fly data race detection
in multithreaded C++ programs . . . . . 179--190
Ankit Goel and
Abhik Roychoudhury and
Tulika Mitra Compactly representing parallel program
executions . . . . . . . . . . . . . . . 191--202
Kai Tan and
Duane Szafron and
Jonathan Schaeffer and
John Anvik and
Steve MacDonald Using generative design patterns to
generate parallel code for a distributed
memory environment . . . . . . . . . . . 203--215
Kenjiro Taura and
Kenji Kaneda and
Toshio Endo and
Akinori Yonezawa Phoenix: a parallel programming model
for accommodating dynamically
joining/leaving resources . . . . . . . 216--229
Steven Saunders and
Lawrence Rauchwerger ARMI: an adaptive, platform independent
communication library . . . . . . . . . 230--240
John Hatcliff and
William Deng and
Matthew B. Dwyer and
Georg Jung and
Venkatesh Ranganath and
Robby Slicing and partial evaluation of CORBA
component model designs for avionics
system . . . . . . . . . . . . . . . . . 241--242
Mads Sig Ager and
Olivier Danvy and
Henning Korsholm Rohde Fast partial evaluation of pattern
matching in strings . . . . . . . . . . 243--249
Robert Glück and
Youhei Kawada and
Takuya Hashimoto Transforming interpreters into inverse
interpreters by partial evaluation . . . 250--259
Chiyan Chen and
Hongwei Xi Implementing typeful program
transformations . . . . . . . . . . . . 260--268
Germán Puebla and
Manuel Hermenegildo Abstract specialization and its
applications . . . . . . . . . . . . . . 269--283
Matthew Allen and
Susan Horwitz Slicing Java programs that throw and
catch exceptions . . . . . . . . . . . . 284--294
Marius Bozga and
Radu Iosif and
Yassine Laknech Storeless semantics and alias logic . . 295--305
Giuseppe Attardi and
Antonio Cisternino and
Andrew Kennedy CodeBricks: code fragments as building
blocks . . . . . . . . . . . . . . . . . 306--314
Wei-Ngan Chin and
Siau-Cheng Khoo and
Dana N. Xu Extending sized type with collection
analysis . . . . . . . . . . . . . . . . 315--324
Yanhong A. Liu and
Scott D. Stoller Optimizing Ackermann's function by
incrementalization . . . . . . . . . . . 325--331
Donal Lafferty and
Vinny Cahill Language-independent aspect-oriented
programming . . . . . . . . . . . . . . 1--12
Frank Tip and
Adam Kiezun and
Dirk Bäumer Refactoring for generalization using
type constraints . . . . . . . . . . . . 13--26
Éric Tanter and
Jacques Noyé and
Denis Caromel and
Pierre Cointe Partial behavioral reflection: spatial
and temporal selection of reification 27--46
Andrew P. Black and
Nathanael Schärli and
Stéphane Ducasse Applying traits to the Smalltalk
collection classes . . . . . . . . . . . 47--64
Philippe Mougin and
Stéphane Ducasse OOPAL: integrating array programming in
object-oriented programming . . . . . . 65--77
Brian Demsky and
Martin Rinard Automatic detection and repair of errors
in data structures . . . . . . . . . . . 78--95
Eric Allen and
Jonathan Bannet and
Robert Cartwright A first-class approach to genericity . . 96--114
Ronald Garcia and
Jaakko Jarvi and
Andrew Lumsdaine and
Jeremy Siek and
Jeremiah Willcock A comparative study of language support
for generic programming . . . . . . . . 115--134
Tian Zhao and
Jens Palsber and
Jan Vite Lightweight confinement for
featherweight Java . . . . . . . . . . . 135--148
Bruno Dufour and
Karel Driesen and
Laurie Hendren and
Clark Verbrugge Dynamic metrics for Java . . . . . . . . 149--168
Lieven Eeckhout and
Andy Georges and
Koen De Bosschere How Java programs interact with virtual
machines at the microarchitectural level 169--186
Kazuaki Ishizaki and
Mikio Takeuchi and
Kiyokuni Kawachiya and
Toshio Suganuma and
Osamu Gohda and
Tatsushi Inagaki and
Akira Koseki and
Kazunori Ogata and
Motohiro Kawahito and
Toshiaki Yasue and
Takeshi Ogasawara and
Tamiya Onodera and
Hideaki Komatsu and
Toshio Nakatani Effectiveness of cross-platform
optimizations for a Java just-in-time
compiler . . . . . . . . . . . . . . . . 187--204
Keunwoo Lee and
Anthony LaMarca and
Craig Chambers HydroJ: object-oriented pattern matching
for evolvable distributed systems . . . 205--223
Todd Millstein and
Mark Reay and
Craig Chambers Relaxed MultiJava: balancing
extensibility and modular typechecking 224--240
John Corwin and
David F. Bacon and
David Grove and
Chet Murthy MJ: a rational module system for Java
and its applications . . . . . . . . . . 241--254
Katherine Barabash and
Yoav Ossia and
Erez Petrank Mostly concurrent garbage collection
revisited . . . . . . . . . . . . . . . 255--268
Hezi Azatchi and
Yossi Levanoni and
Harel Paz and
Erez Petrank An on-the-fly mark and sweep garbage
collector based on sliding views . . . . 269--281
G. Chen and
M. Kandemir and
N. Vijaykrishnan and
M. J. Irwin and
B. Mathiske and
M. Wolczko Heap compression for memory-constrained
Java environments . . . . . . . . . . . 282--301
Manuel Fähndrich and
K. Rustan M. Leino Declaring and checking non-null types in
an object-oriented language . . . . . . 302--312
Darko Marinov and
Robert O'Callahan Object equality profiling . . . . . . . 313--325
Narendran Sachindran and
J. Eliot and
B. Moss Mark-copy: fast copying GC with less
space overhead . . . . . . . . . . . . . 326--343
Stephen M. Blackburn and
Kathryn S. McKinley Ulterior reference counting: fast
garbage collection without a long wait 344--358
Martin Hirzel and
Amer Diwan and
Matthew Hertz Connectivity-based garbage collection 359--373
Dave Clarke and
Michael Richmond and
James Noble Saving the world from bad beans:
deployment-time confinement checking . . 374--387
Tim Harris and
Keir Fraser Language support for lightweight
transactions . . . . . . . . . . . . . . 388--402
Chandrasekhar Boyapati and
Barbara Liskov and
Liuba Shrira and
Chuang-Hue Moh and
Steven Richman Lazy modular upgrades in persistent
object stores . . . . . . . . . . . . . 403--417
Michael G. Burke Executive Committee October 2003 Meeting
Report . . . . . . . . . . . . . . . . . 1--1
Jay Fenwick and
Cindy Norris Letters from the Editors . . . . . . . . 2--2
Philip Wadler and
Krzysztof R. Apt and
Matthias Felleisen Reminiscences on Influential Papers
[Definitional interpreters for
higher-order programming languages;
Structured Programming; Call-by-name,
Call-by-value, and the
$\lambda$-calculus] . . . . . . . . . . 2--2
Alan Creak Programming lessons from days gone by:
extreme design . . . . . . . . . . . . . 11--16
Jay Fenwick and
Cindy Norris Information for Authors . . . . . . . . 17--17
Walter L. (Larry) Griffith Letter to the Editor: Some Deficiencies
of C++ in Teaching CS1 and CS2 . . . . . 18--19
Marco Avvenuti and
Cinzia Bernardeschi and
Nicoletta De Francesco Java bytecode verification for secure
information flow . . . . . . . . . . . . 20--27
John Aycock The ART of compiler construction
projects . . . . . . . . . . . . . . . . 28--32
Cristina Videira Lopes and
Paul Dourish and
David H. Lorenz and
Karl Lieberherr Beyond AOP: toward naturalistic
programming . . . . . . . . . . . . . . 34--43
Sam Kamin Routine run-time code generation . . . . 44--56
Martin Rinard Acceptability-oriented computing . . . . 57--75
Robert Biddle and
Angela Martin and
James Noble No name: just notes on software reuse 76--96
Xavier Rival Symbolic transfer function-based
approaches to certified compilation . . 1--13
Nick Benton Simple relational correctness proofs for
static analyses and program
transformations . . . . . . . . . . . . 14--25
Ganesh Sittampalam and
Oege de Moor and
Ken Friis Larsen Incremental execution of transformation
specifications . . . . . . . . . . . . . 26--38
Dachuan Yu and
Andrew Kennedy and
Don Syme Formalization of generics for the .NET
common language runtime . . . . . . . . 39--51
Jerome Vouillon and
Paul-André Melli\`es Semantic types: a fresh look at the
ideal model for types . . . . . . . . . 52--63
Vincent Balat and
Roberto Di Cosmo and
Marcelo Fiore Extensional normalisation and
type-directed partial evaluation for
typed lambda calculus with sums . . . . 64--76
Marcelo Fiore Isomorphisms of generic recursive
polynomial types . . . . . . . . . . . . 77--88
François Pottier and
Nadji Gauthier Polymorphic typed defunctionalization 89--98
Patricia Johann and
Janis Voigtländer Free theorems in the presence of seq . . 99--110
Bryan Ford Parsing expression grammars: a
recognition-based syntactic foundation 111--122
Denis Caromel and
Ludovic Henrio and
Bernard Paul Serpette Asynchronous and deterministic objects 123--134
Silvano Dal Zilio and
Denis Lugiez and
Charles Meyssonnier A logic you can count on . . . . . . . . 135--146
Nobuko Yoshida Channel dependent types for higher-order
mobile processes . . . . . . . . . . . . 147--160
Eijiro Sumii and
Benjamin C. Pierce A bisimulation for dynamic sealing . . . 161--172
Patrick Cousot and
Radhia Cousot An abstract interpretation-based
framework for software watermarking . . 173--185
Roberto Giacobazzi and
Isabella Mastroeni Abstract non-interference:
parameterizing non-interference by
abstract interpretation . . . . . . . . 186--197
Karthikeyan Bhargavan and
Cédric Fournet and
Andrew D. Gordon A semantics for Web services
authentication . . . . . . . . . . . . . 198--209
Hans-J. Boehm The space cost of lazy reference
counting . . . . . . . . . . . . . . . . 210--219
Lars Birkedal and
Noah Torp-Smith and
John C. Reynolds Local reasoning about a copying garbage
collector . . . . . . . . . . . . . . . 220--231
Thomas A. Henzinger and
Ranjit Jhala and
Rupak Majumdar and
Kenneth L. McMillan Abstractions from proofs . . . . . . . . 232--244
Shaz Qadeer and
Sriram K. Rajamani and
Jakob Rehof Summarizing procedures in concurrent
programs . . . . . . . . . . . . . . . . 245--255
Cormac Flanagan and
Stephen N. Freund Atomizer: a dynamic atomicity checker
for multithreaded programs . . . . . . . 256--267
Peter W. O'Hearn and
Hongseok Yang and
John C. Reynolds Separation and information hiding . . . 268--280
Joshua Dunfield and
Frank Pfenning Tridirectional typechecking . . . . . . 281--292
Derek Dreyer A type system for well-founded recursion 293--305
Davide Ancona and
Elena Zucca Principal typings for Java-like
languages . . . . . . . . . . . . . . . 306--317
Sriram Sankaranarayanan and
Henny B. Sipma and
Zohar Manna Non-linear loop invariant generation
using Gröbner bases . . . . . . . . . . . 318--329
Markus Müller-Olm and
Helmut Seidl Precise interprocedural analysis through
linear algebra . . . . . . . . . . . . . 330--341
Sumit Gulwani and
George C. Necula Global value numbering using random
interpretation . . . . . . . . . . . . . 342--352
Paul Frenger Dutch treat . . . . . . . . . . . . . . 7--10
Awadhesh Kumar Singh and
Anup Kumar Bandyopadhyay Adding the leads-to operator to
Dijkstra's calculus . . . . . . . . . . 12--17
Hongmin Lu and
Yuming Zhou and
Jiangtao Lu and
Baowen Xu A compile-time optimization framework
for Ada rendezvous . . . . . . . . . . . 18--25
Litong Song and
Krishna Kavi What can we gain by unfolding loops? . . 26--33
Yuan Liu and
Baowen Xu Process algebra model of Ada protected
objects . . . . . . . . . . . . . . . . 34--39
Paul Frenger Deus Ex Macintosh . . . . . . . . . . . 7--11
Yingzhou Zhang and
Baowen Xu A survey of semantic description
frameworks for programming languages . . 14--30
Jonathan Yavner Back-propagation of knowledge from
syntax tree to C source code . . . . . . 31--37
K. V. Seshu Kumar When and what to compile/optimize in a
virtual machine? . . . . . . . . . . . . 38--45
Patrick Lam and
Viktor Kuncak and
Martin Rinard Generalized typestate checking using set
interfaces and pluggable analyses . . . 46--55
Anonymous Forth report . . . . . . . . . . . . . . ??
R. G. G. Cattell and
Joseph M. Newcomer and
Bruce W. Leverett Code generation in a machine-independent
compiler . . . . . . . . . . . . . . . . 1--13
Thomas J. Pennello and
Frank DeRemer Efficient computation of LALR(1)
look-ahead sets . . . . . . . . . . . . 14--27
Manfred Minimair MR: Macaulay Resultant package for Maple 26--29
Frances E. Allen and
Janet Fabri Automatic storage optimization . . . . . 28--37
Marc Auslander and
Martin Hopkins An overview of the PL.8 compiler . . . . 38--48
Susan L. Graham and
Peter B. Kessler and
Marshall K. McKusick gprof: a call graph execution profiler 49--57
Victoria Markstein and
Peter Markstein and
John Cocke Optimization of range checking . . . . . 58--65
Gregory Chaitin Register allocation and spilling via
graph coloring . . . . . . . . . . . . . 66--74
Randy Allen and
Ken Kennedy Automatic loop interchange . . . . . . . 75--90
Fred Chow and
John Hennessy Register allocation by priority-based
coloring . . . . . . . . . . . . . . . . 91--103
Jack W. Davidson and
Christopher W. Fraser Automatic generation of peephole
optimizations . . . . . . . . . . . . . 104--111
Joseph A. Fisher and
John R. Ellis and
John C. Ruttenberg and
Alexandru Nicolau Parallel processing: a smart compiler
and a dumb machine . . . . . . . . . . . 112--124
Thomas Johnsson Efficient compilation of lazy evaluation 125--138
Michael G. Burke and
Ron K. Cytron Interprocedural dependence analysis and
parallelization . . . . . . . . . . . . 139--154
David Callahan and
Keith D. Cooper and
Ken Kennedy and
Linda Torczon Interprocedural constant propagation . . 155--166
Steven S. Muchnick and
Phillip B. Gibbons Efficient instruction scheduling for a
pipelined architecture . . . . . . . . . 167--174
David Kranz and
Richard Kelsey and
Jonathan Rees and
Paul Hudak and
James Philbin and
Norman Adams Orbit: an optimizing compiler for Scheme 175--191
David W. Wall Global register allocation at link time 192--204
Andrew W. Appel Real-time concurrent collection on stock
multiprocessors . . . . . . . . . . . . 205--216
Keith D. Cooper and
Ken Kennedy Interprocedural side-effect analysis in
linear time . . . . . . . . . . . . . . 217--228
Susan Horwitz and
Thomas Reps and
David Binkley Interprocedural slicing using dependence
graphs . . . . . . . . . . . . . . . . . 229--243
Monica S. Lam Software pipelining: an effective
scheduling technique for VLIW machines 244--256
Olin Shivers Higher-order control-flow analysis in
retrospect: lessons learned, lessons
abandoned . . . . . . . . . . . . . . . 257--269
David W. Wall Register windows vs. register allocation 270--282
Preston Briggs and
Keith D. Cooper and
Ken Kennedy and
Linda Torczon Coloring heuristics for register
allocation . . . . . . . . . . . . . . . 283--294
Craig Chambers and
David Ungar A retrospective on: ``Customization:
Optimizing Compiler Technology for Self,
a Dynamically-Typed Object-Oriented
Programming Language'' . . . . . . . . . 295--312
Edith Schonberg On-the-fly detection of access anomalies 313--327
David Callahan and
Steve Carr and
Ken Kennedy Improving register allocation for
subscripted variables . . . . . . . . . 328--342
David Chase and
Mark Wegman and
F. Ken Zadeck Analysis of pointers and structures . . 343--359
William D. Clinger How to read floating point numbers
accurately . . . . . . . . . . . . . . . 360--371
William D. Clinger Retrospective: How to read floating
point numbers accurately . . . . . . . . 360--371
Guy L. Steele Jr. and
Jon L. White Retrospective: How to Print
Floating-Point Numbers Accurately . . . 372--389
Peter B. Kessler Fast breakpoints: design and
implementation . . . . . . . . . . . . . 390--397
Karl Pettis and
Robert C. Hansen and
Jack W. Davidson Profile guided code positioning . . . . 398--411
Robert Cartwright and
Mike Fagan Soft typing . . . . . . . . . . . . . . 412--428
David W. Wall Predicting program behavior using real
or estimated profiles . . . . . . . . . 429--441
Monica S. Lam and
Michael E. Wolf A data locality optimizing algorithm . . 442--459
Jens Knoop and
Oliver Rüthing and
Bernhard Steffen Lazy code motion . . . . . . . . . . . . 460--472
William Landi and
Barbara G. Ryder A safe approximate algorithm for
interprocedural pointer aliasing . . . . 473--489
Hans J. Boehm Space efficient conservative garbage
collection . . . . . . . . . . . . . . . 490--501
Cormac Flanagan and
Amr Sabry and
Bruce F. Duba and
Matthias Felleisen The essence of compiling with
continuations . . . . . . . . . . . . . 502--514
Daniel R. Kerns and
Susan J. Eggers Balanced scheduling: instruction
scheduling when memory latency is
uncertain . . . . . . . . . . . . . . . 515--527
Amitabh Srivastava and
Alan Eustace ATOM: a system for building customized
program analysis tools . . . . . . . . . 528--539
Peter Lee and
Mark Leone Optimizing ML with run-time code
generation . . . . . . . . . . . . . . . 540--553
David Tarditi and
Greg Morrisett and
Perry Cheng and
Chris Stone and
Robert Harper and
Peter Lee TIL: a type-directed, optimizing
compiler for ML . . . . . . . . . . . . 554--567
Glenn Ammons and
James R. Larus Improving data-flow analysis with path
profiles . . . . . . . . . . . . . . . . 568--582
David F. Bacon and
Ravi Konuru and
Chet Murthy and
Mauricio J. Serrano Thin locks: featherweight
synchronization for Java . . . . . . . . 583--595
Rastislav Bodík and
Rajiv Gupta and
Mary Lou Soffa Complete removal of redundant
expressions . . . . . . . . . . . . . . 596--611
George C. Necula and
Peter Lee The design and implementation of a
certifying compiler . . . . . . . . . . 612--625
Guy E. Blelloch and
Perry Cheng On bounding time and space for
multiprocessor garbage collection . . . 626--641
Matteo Frigo A fast Fourier transform compiler . . . 642--655
Brian Grant and
Matthai Philipose and
Markus Mock and
Craig Chambers and
Susan J. Eggers A retrospective on: ``an evaluation of
staged run-time optimizations in DyC'' 656--669
Chung-chieh Shan Sexy types in action . . . . . . . . . . 15--22
Debasish Ghosh Generics in Java and C++: a comparative
model . . . . . . . . . . . . . . . . . 40--47
Paul Damian Wells A universal intermediate representation
for massively parallel software
development . . . . . . . . . . . . . . 48--57
Matjaz B. Juric and
Bostjan Kezmah and
Marjan Hericko and
Ivan Rozman and
Ivan Vezocnik Java RMI, RMI tunneling and Web services
comparison and performance analysis . . 58--65
Isaiah Pinchas Kantorovitz Lexical analysis tool . . . . . . . . . 66--74
Thomas A. Henzinger and
Ranjit Jhala and
Rupak Majumdar Race checking by context inference . . . 1--13
Shaz Qadeer and
Dinghao Wu KISS: keep it simple and sequential . . 14--24
Eran Yahav and
G. Ramalingam Verifying safety properties using
separation and heterogeneous
abstractions . . . . . . . . . . . . . . 25--34
Maged M. Michael Scalable lock-free dynamic memory
allocation . . . . . . . . . . . . . . . 35--46
Matthew Flatt and
Robert Bruce Findler Kill-safe synchronization abstractions 47--58
Troy A. Johnson and
Rudolf Eigenmann and
T. N. Vijaykumar Min-cut program decomposition for
thread-level speculation . . . . . . . . 59--70
Zhao-Hui Du and
Chu-Cheow Lim and
Xiao-Feng Li and
Chen Yang and
Qingyu Zhao and
Tin-Fook Ngai A cost-driven compilation framework for
speculative parallelization of
sequential programs . . . . . . . . . . 71--81
Alexandre E. Eichenberger and
Peng Wu and
Kevin O'Brien Vectorization for SIMD architectures
with alignment constraints . . . . . . . 82--93
Xiangyu Zhang and
Rajiv Gupta Cost effective dynamic program slicing 94--106
C. Collberg and
E. Carter and
S. Debray and
A. Huntwork and
J. Kececioglu and
C. Linn and
M. Stepp Dynamic path-based software watermarking 107--118
Cheng Wang and
Zhiyuan Li Parametric analysis for adaptive
computation offloading . . . . . . . . . 119--130
John Whaley and
Monica S. Lam Cloning-based context-sensitive pointer
alias analysis using binary decision
diagrams . . . . . . . . . . . . . . . . 131--144
Jianwen Zhu and
Silvian Calman Symbolic pointer analysis revisited . . 145--157
Ond\vrej Lhoták and
Laurie Hendren Jedd: a BDD-based relational extension
of Java . . . . . . . . . . . . . . . . 158--169
Prasad Kulkarni and
Stephen Hines and
Jason Hiser and
David Whalley and
Jack Davidson and
Douglas Jones Fast searches for effective optimization
phase sequences . . . . . . . . . . . . 171--182
John Cavazos and
J. Eliot and
B. Moss Inducing heuristics to decide whether to
schedule . . . . . . . . . . . . . . . . 183--194
Manish Vachharajani and
Neil Vachharajani and
David I. August The liberty structural specification
language: a high-level modeling language
for component reuse . . . . . . . . . . 195--206
John Kodumal and
Alex Aiken The set constraint/CFL reachability
connection in practice . . . . . . . . . 207--218
Yanhong A. Liu and
Tom Rothamel and
Fuxiang Yu and
Scott D. Stoller and
Nanjun Hu Parametric regular path queries . . . . 219--230
Arnaud Venet and
Guillaume Brat Precise and efficient static array bound
checking for large embedded C programs 231--242
Wei-Ngan Chin and
Florin Craciun and
Shengchao Qin and
Martin Rinard Region inference for an object-oriented
language . . . . . . . . . . . . . . . . 243--254
Yutao Zhong and
Maksim Orlovich and
Xipeng Shen and
Chen Ding Array regrouping and structure splitting
using whole-program reference affinity 255--266
Ali-Reza Adl-Tabatabai and
Richard L. Hudson and
Mauricio J. Serrano and
Sreenivas Subramoney Prefetch inection based on hardware
monitoring and object metadata . . . . . 267--276
Michael D. Smith and
Norman Ramsey and
Glenn Holloway A generalized algorithm for
graph-coloring register allocation . . . 277--288
Xiaotong Zhuang and
Santosh Pande Balancing register allocation across
threads for a multithreaded network
processor . . . . . . . . . . . . . . . 289--300
Iosif Antochi and
Ben Juurlink and
Stamatis Vassiliadis and
Petri Liuha GraalBench: a $3$D graphics benchmark
suite for mobile phones . . . . . . . . 1--9
Thomas Martin and
Mark Jones and
Joshua Edmison and
Tanwir Sheikh and
Zahi Nakad Modeling and simulating electronic
textile applications . . . . . . . . . . 10--19
Paul Willmann and
Michael Brogioli and
Vijay S. Pai Spinach: a liberty-based simulator for
programmable network interface
architectures . . . . . . . . . . . . . 20--29
Christopher L. Conway and
Stephen A. Edwards NDL: a domain-specific language for
device drivers . . . . . . . . . . . . . 30--36
Nagendra J. Kumar and
Siddhartha Shivshankar and
Alexander G. Dean Asynchronous software thread integration
for efficient software . . . . . . . . . 37--46
Wei Qin and
Subramanian Rajagopalan and
Sharad Malik A formal concurrency model based
architecture description language for
synthesis of software development tools 47--56
Ravindra Jejurikar and
Rajesh Gupta Procrastination scheduling in fixed
priority real-time systems . . . . . . . 57--66
Xiaotong Zhuang and
Santosh Pande Power-efficient prefetching via
bit-differential offset assignment on
embedded processors . . . . . . . . . . 67--77
Gilles Pokam and
Olivier Rochecouste and
André Seznec and
François Bodin Speculative software management of
datapath-width for energy optimization 78--87
Chaeseok Im and
Soonhoi Ha Dynamic voltage scaling for real-time
multi-task scheduling using buffers . . 88--94
Lian Li and
Jingling Xue A trace-based binary compilation
framework for energy-aware computing . . 95--106
J. Lapalme and
E. M. Aboulhamid and
G. Nicolescu and
L. Charest and
F. R. Boyer and
J. P. David and
G. Bois ESys.Net: a new solution for embedded
systems modeling and simulation . . . . 107--114
Gilberto Contreras and
Margaret Martonosi and
Jinzhan Peng and
Roy Ju and
Guei-Yuan Lueh XTREM: a power simulator for the Intel
XScale\TM; core . . . . . . . . . . . . 115--125
Uwe Kastens and
Dinh Khoi Le and
Adrian Slowik and
Michael Thies Feedback driven instruction-set
extension . . . . . . . . . . . . . . . 126--135
Kaustubh Patil and
Kiran Seth and
Frank Mueller Compositional static instruction cache
simulation . . . . . . . . . . . . . . . 136--145
Johan Stärner and
Lars Asplund Measuring the cache interference cost in
preemptive real-time systems . . . . . . 146--154
Lingli Zhang and
Chandra Krintz Adaptive code unloading for
resource-constrained JVMs . . . . . . . 155--164
Peng Li and
Steve Zdancewic Advanced control flow in Java card
programming . . . . . . . . . . . . . . 165--174
Jia Zeng and
Cristian Soviani and
Stephen A. Edwards Generating fast code from concurrent
program dependence graphs . . . . . . . 175--181
Jason D. Hiser and
Jack W. Davidson EMBARC: an efficient memory bank
assignment algorithm for retargetable
compilers . . . . . . . . . . . . . . . 182--191
Xiaotong Zhuang and
Tao Zhang and
Santosh Pande Hardware-managed register allocation for
embedded processors . . . . . . . . . . 192--201
Jean-Marc Daveau and
Thomas Thery and
Thierry Lepley and
Miguel Santana A retargetable register allocation
framework for embedded processors . . . 202--210
Bruno De Bus and
Bjorn De Sutter and
Ludo Van Put and
Dominique Chanet and
Koen De Bosschere Link-time optimization of ARM binaries 211--220
Bernhard Scholz and
Nigel Horspool and
Jens Knoop Optimizing for space and time usage with
speculative partial redundancy
elimination . . . . . . . . . . . . . . 221--230
L. Almagor and
Keith D. Cooper and
Alexander Grosul and
Timothy J. Harvey and
Steven W. Reeves and
Devika Subramanian and
Linda Torczon and
Todd Waterman Finding effective compilation sequences 231--239
H. Saputra and
G. Chen and
R. Brooks and
N. Vijaykrishnan and
M. Kandemir and
M. J. Irwin Code protection for resource-constrained
embedded devices . . . . . . . . . . . . 240--248
Zhi Guo and
Betul Buyukkurt and
Walid Najjar Input data reuse in compiling window
operations onto reconfigurable hardware 249--256
Andrzej Wasowski Flattening statecharts without
explosions . . . . . . . . . . . . . . . 257--266
Paul Frenger Embed with Forth . . . . . . . . . . . . 8--11
Alan Creak Parsing by numbers and asparagus . . . . 12--19
John Reid An overview of Fortran 2003 . . . . . . 31--38
Fangjun Wu and
Tong Yi Slicing Z specifications . . . . . . . . 39--48
Dmitri Bronnikov A practical adoption of partial
redundancy elimination . . . . . . . . . 49--53
José de Oliveira Guimarães Closures for statically-typed
object-oriented languages . . . . . . . 54--60
Chitra Babu and
D. Janakiram Method driven model: a unified model for
an object composition language . . . . . 61--71
S. M. Sandya Jazzing up JVMs with off-line profile
data: does it pay? . . . . . . . . . . . 72--80
Norman Ramsey and
Simon L. Peyton Jones The C--compiler infrastructure . . . . . 1--1
John Launchbury Galois: high assurance software . . . . 3--3
Simon Marlow and
Simon Peyton Jones Making a fast curry: push/enter vs.
eval/apply for higher-order languages 4--15
David Herman and
Philippe Meunier Improving the static analysis of
embedded languages via partial
evaluation . . . . . . . . . . . . . . . 16--27
Jan Christiansen and
Frank Huch Searching for deadlocks while debugging
Concurrent Haskell programs . . . . . . 28--39
Zena M. Ariola and
Hugo Herbelin and
Amr Sabry A type-theoretic foundation of
continuations and prompts . . . . . . . 40--53
Mitchell Wand and
Dale Vaillancourt Relating models of backtracking . . . . 54--65
Paul Graham Don't make the wrong mistakes:
programming as debugging . . . . . . . . 66--66
Niklas Broberg and
Andreas Farre and
Josef Svenningsson Regular expression patterns . . . . . . 67--78
Olin Shivers and
David Fisher Multi-return function call . . . . . . . 79--89
Andrew Tolmach and
Sergio Antoy and
Marius Nita Implementing functional logic languages
using multiple threads and stores . . . 90--102
Matthew Fluet and
Greg Morrisett Monadic regions . . . . . . . . . . . . 103--114
Stephen Tse and
Steve Zdancewic Translating dependency into
parametricity . . . . . . . . . . . . . 115--125
Dario Colazzo and
Giorgio Ghelli and
Paolo Manghi and
Carlo Sartiani Types for path correctness of XML
queries . . . . . . . . . . . . . . . . 126--137
Peter Mòller Neergaard and
Harry G. Mairson Types, potency, and idempotency: why
nonlinearity and amnesia make a type
system work . . . . . . . . . . . . . . 138--149
Nadji Gauthier and
François Pottier Numbering matters: first-order canonical
forms for second-order recursive types 150--161
Ulf Wiger 20 years of industrial functional
programming . . . . . . . . . . . . . . 162--162
Kohei Honda From process logic to program logic . . 163--174
Dachuan Yu and
Zhong Shao Verification of safety properties for
concurrent assembly code . . . . . . . . 175--188
Matthias Blume and
David McAllester A sound (and complete) model of
contracts . . . . . . . . . . . . . . . 189--200
Dipanwita Sarkar and
Oscar Waddell and
R. Kent Dybvig A nanopass infrastructure for compiler
education . . . . . . . . . . . . . . . 201--212
Markus Forsberg and
Aarne Ranta Functional morphology . . . . . . . . . 213--223
Robert Bruce Findler and
Matthew Flatt Slideshow: functional presentations . . 224--235
Ralf Hinze Generics for the masses . . . . . . . . 236--243
Ralf Lämmel and
Simon Peyton Jones Scrap more boilerplate: reflection,
zips, and generalised casts . . . . . . 244--255
Roly Perera Refactoring: to the Rubicon\ldots and
beyond! . . . . . . . . . . . . . . . . 2--3
Steve Freeman and
Tim Mackinnon and
Nat Pryce and
Joe Walnes jMock: supporting responsibility-based
design with mock objects . . . . . . . . 4--5
Jonathan Aldrich and
David Garlan and
Bradley Schmerl and
Tony Tseng Modeling and implementing software
architecture with acme and archJava . . 6--7
Robert Fuhrer and
Frank Tip and
Adam Kie\.zun Advanced refactorings in eclipse . . . . 8--8
Edward McCormick and
Kris De Volder JQuery: finding your way through tangled
code . . . . . . . . . . . . . . . . . . 9--10
Murali Kaundinya and
Ali Syed Modeling event driven applications with
a specification language (MEDASL) . . . 11--12
Vibha Sazawal and
David Notkin Design snippets: partial design
representations extracted from source
code . . . . . . . . . . . . . . . . . . 13--14
Matthew Fowler and
Brahm van Niekerk Meta-programming for the real world . . 15--15
Helena Åberg Östlund JRA: offline analysis of runtime
behaviour . . . . . . . . . . . . . . . 16--17
Olaf Spinczyk and
Danilo Beuche Modeling and building software product
lines with eclipse . . . . . . . . . . . 18--19
Charles Zhang and
Hans-Arno Jacobsen PRISM is research in aSpect mining . . . 20--21
Arnab Bhattacharrya and
Robert Fuhrer Smell detection for eclipse . . . . . . 22--22
Martin Lippert AJEER: an aspectJ-enabled eclipse
runtime . . . . . . . . . . . . . . . . 23--24
Robert L. Akers and
Ira D. Baxter and
Michael Mehlich Program transformations for
re-engineering C++ components
[OOPSLA/GPCE] . . . . . . . . . . . . . 25--26
Jeff Gray and
Jing Zhang and
Suman Roychoudhury and
Ira Baxter C-SAW and genAWeave: a two-level aspect
weaving toolsuite . . . . . . . . . . . 27--28
Peri Tarr and
William Chung and
William Harrison and
Vincent Kruskal and
Harold Ossher and
Stanley M. Sutton, Jr. and
Andrew Clement and
Matthew Chapman and
Helen Hawkins and
Sian January The concern manipulation environment
[OOPSLA/GPCE] . . . . . . . . . . . . . 29--30
Matthias Hauswirth and
Peter F. Sweeney and
Amer Diwan Performance explorer: understanding Java
application behavior . . . . . . . . . . 31--32
Donald Gordon and
James Noble and
Robert Biddle ConstrainedJava . . . . . . . . . . . . 33--34
Tien N. Nguyen and
Ethan V. Munson and
John T. Boyland Object-oriented, structural software
configuration management . . . . . . . . 35--36
Didier Parigot Towards domain-driven development: the
smartTools software factory . . . . . . 37--38
Juha-Pekka Tolvanen MetaEdit+: domain-specific modeling for
full code generation demonstrated [GPCE] 39--40
Miguel Guerrero and
Edward Pizzi and
Robert Rosenbaum and
Kedar Swadi and
Walid Taha Implementing DSLs in metaOCaml . . . . . 41--42
Michael Eichberg and
Thorsten Schäfer XIRC: cross-artifact information
retrieval [GPCE] . . . . . . . . . . . . 43--44
Lan Cao Modeling dynamics of agile software
development . . . . . . . . . . . . . . 46--47
Paul V. Gestwicki Interactive visualization of
object-oriented programs . . . . . . . . 48--49
Alex Potanin and
James Noble and
Robert Biddle Generic ownership: practical ownership
control in programming languages . . . . 50--51
Suman Roychoudhury A language-independent approach to
software maintenance using grammar
adapters . . . . . . . . . . . . . . . . 52--53
Jeremy Siek Modular generics . . . . . . . . . . . . 54--55
Piotr Nienaltowski Efficient data race and deadlock
prevention in concurrent object-oriented
programs . . . . . . . . . . . . . . . . 56--57
Mircea Trofin A framework for removing redundant
context management services in
Enterprise JavaBeans application servers 58--59
Raul Silaghi Refining designs along
middleware-specific concern-dimensions
at different MDA-levels of abstraction 60--62
Axel Schmolitzky ``Objects first, interfaces next'' or
interfaces before inheritance . . . . . 64--67
Phil Ventura and
Christopher Egert and
Adrienne Decker Ancestor worship in CS1: on the primacy
of arrays . . . . . . . . . . . . . . . 68--72
Poul Henriksen and
Michael Kölling greenfoot: combining object
visualisation with interaction . . . . . 73--82
Katherine Malan and
Ken Halland Examples that can do harm in learning
programming . . . . . . . . . . . . . . 83--87
Kurt D. Fenstermacher If I had a model, I'd model in the
mornin' . . . . . . . . . . . . . . . . 88--95
Kim B. Bruce and
Andrea Danyluk Event-driven programming facilitates
learning standard programming concepts 96--100
Eric Cheng and
Dung Zung Nguyen and
Mathias Ricken and
Stephen Wong Abstract factories and the shape
calculator . . . . . . . . . . . . . . . 101--102
Michael R. Wick Using the game of life to introduce
freshman students to the power and
elegance of design patterns . . . . . . 103--105
Christopher H. Nevison From concrete to abstract: the power of
generalization . . . . . . . . . . . . . 106--108
Eric Cheng and
Dung Zung Nguyen and
Mathias Ricken and
Stephen Wong Marine biology simulation . . . . . . . 109--110
James Noble and
Robert Biddle Notes on notes on postmodern
programming: radio edit . . . . . . . . 112--115
Tim Sheard Languages of the future . . . . . . . . 116--119
Munindar P. Singh and
Amit K. Chopra and
Nirmit V. Desai and
Ashok U. Mallya Protocols for processes: programming in
the large for open systems (extended
abstract) . . . . . . . . . . . . . . . 120--123
Jonathan Edwards Example centric programming . . . . . . 124--124
Brian Marick Methodology work is ontology work . . . 125--125
David West Looking for love: (in all the wrong
places) . . . . . . . . . . . . . . . . 126--127
Yinliang Zhao Granule-oriented programming (extended
abstract) . . . . . . . . . . . . . . . 128--131
David Hovemeyer and
William Pugh Finding bugs is easy . . . . . . . . . . 132--136
Granville Miller and
Scott Ambler and
Steve Cook and
Stephen Mellor and
Karl Frank and
Jon Kern Model driven architecture: the
realities, a year later . . . . . . . . 138--140
Jim Haungs and
Martin Fowler and
Ralph Johnson and
Steve McConnell and
Richard Gabriel Software development: arts & crafts or
math & science? . . . . . . . . . . . . . 141--142
Martin Fowler and
Don Box and
Anders Hejlsberg and
Alan Knight and
Rob High and
John Crupi The great J2EE vs. Microsoft .NET
shootout . . . . . . . . . . . . . . . . 143--144
Steven Fraser and
Lougie Anderson and
Ron Crocker and
Richard Gabriel and
Martin Fowler and
Ricardo Lopez and
Dave Thomas Challenges in outsourcing and global
development: how will your job change? 145--147
Steven Fraser and
Angela Martin and
Robert Biddle and
David Hussman and
Granville Miller and
Mary Poppendieck and
Linda Rising and
Mark Striebeck The role of the customer in software
development: the XP customer --- fad or
fashion? . . . . . . . . . . . . . . . . 148--150
Nicolai M. Josuttis and
Jutta Eckstein and
Linda Rising and
Lise B. Hvatum and
Mary Lynn Manns and
Rebecca Wirfs-Brock The view: the ultimate IT chat . . . . . 151--152
Frank Eliassen and
Richard Staehli and
Gordon Blair and
Jan Òyvind Aagedal QuA: building with reusable QoS-aware
components . . . . . . . . . . . . . . . 154--155
Jonathan Aldrich and
David Garlan and
Bradley Schmerl and
Tony Tseng Modeling and implementing software
architecture with acme and archJava . . 156--157
Lawrence Carleton An invitation to the dance of progress 158--159
Virginia Niculescu OOLACA: an object oriented library for
abstract and computational algebra . . . 160--161
Geoff Sobering and
Levi Cook and
Steve Anderson Pseudo-classes: very simple and
lightweight mockObject-like classes for
unit-testing . . . . . . . . . . . . . . 162--163
Joey Paquet and
Aihua Wu and
Peter Grogono Towards a framework for the general
intensional programming compiler in the
GIPSY . . . . . . . . . . . . . . . . . 164--165
Uirá Kulesza and
Alessandro Garcia and
Carlos Lucena An aspect-oriented generative approach 166--167
Murali Kaundinya and
Ali Syed Modeling event driven applications with
a specification language (MEDASL) . . . 168--169
Tauqeer Hussain and
Shafay Shamail and
Mian M. Awais Improving quality in conceptual modeling 170--171
Dries Buytaert and
Andy Georges and
Lieven Eeckhout and
Koen De Bosschere Bottleneck analysis in Java applications
using hardware performance monitors . . 172--173
Pekka Abrahamsson and
Antti Hanhineva and
Hanna Hulkko and
Tuomas Ihme and
Juho Jäälinoja and
Mikko Korkala and
Juha Koskela and
Pekka Kyllönen and
Outi Salo Mobile-D: an agile approach for mobile
application development . . . . . . . . 174--175
A. Szep and
R. Smeikal and
M. Jandl and
K. M. Goeschka Dependable distributed systems . . . . . 176--177
Rilla Khaled and
Anna Maria Luxton and
James Noble and
Leo Ferres and
Judy Brown and
Robert Biddle Visualisation for learning OOP, using
AOP and eclipse . . . . . . . . . . . . 178--179
Martin Lippert AJEER: an aspectJ-enabled eclipse
runtime . . . . . . . . . . . . . . . . 180--181
Gabriel Vögler and
Thomas Flor and
Hajo Eichler and
Matthias Kasprowicz An open model infrastructure for
automotive software . . . . . . . . . . 182--183
Somsak Phattarasukol and
Daisy Sang Design pattern integrated tool . . . . . 184--185
Ben Stephenson and
Wade Holst Advancements in multicode optimization 186--187
Maurizio Lancia and
Paola Garzenini and
Roberto Puccinelli and
Alessio Marchetti J2EE for the public administration: a
success story . . . . . . . . . . . . . 188--189
Wade Holst Meta: extending and unifying languages 190--191
Rafik Amir and
Amir Zeid A UML profile for service oriented
architectures . . . . . . . . . . . . . 192--193
Hoi Chan and
Trieu C. Chieu An approach and tools to automate
externalization of application logic . . 194--195
Therapon Skotiniotis and
David H. Lorenz Cona: aspects for contracts and
contracts for aspects . . . . . . . . . 196--197
Russ Freeman and
Phil Webb $<$CTRL$>$ + $<$ALT$>$ + $<$TOOL PARADIGM
SHIFT$>$? . . . . . . . . . . . . . . . . 198--199
Hironori Washizaki and
Yoshiaki Fukazawa A search system for Java programs by
using extracted JavaBeans components . . 200--201
Leonardo Cole and
Paulo Borba Deriving refactorings for aspectJ . . . 202--203
Bill Pugh and
Jaime Spacco RUBiS revisited: why J2EE benchmarking
is hard . . . . . . . . . . . . . . . . 204--205
Leo Kazuhiro Ueda and
Fabio Kon Mobile musical agents: the andante
project . . . . . . . . . . . . . . . . 206--207
Lorenzo Bettini and
Viviana Bono and
Silvia Likavec A core calculus of mixins and incomplete
objects . . . . . . . . . . . . . . . . 208--209
Bruno Cabral and
Paulo Marques and
Luís Silva RAIL: code instrumentation for .NET . . 210--211
Marat Boshernitsan and
Susan L. Graham iXj: interactive source-to-source
transformations for Java . . . . . . . . 212--213
Leticia R. Rheinheimer and
Junior M. Martins and
Sérgio Crespo C. S. Pinto WSAgent: an agent based on Web services
to promote interoperability between
heterogeneous systems in the health
domain . . . . . . . . . . . . . . . . . 214--215
Sergei Kojarski and
David H. Lorenz AOP as a first class reflective
mechanism . . . . . . . . . . . . . . . 216--217
Aniruddha Gokhale and
Krishnakumar Balasubramanian and
Tao Lu CoSMIC: addressing crosscutting
deployment and configuration concerns of
distributed real-time and embedded
systems . . . . . . . . . . . . . . . . 218--219
Haitham S. Hamza SODA: a stability-oriented domain
analysis method . . . . . . . . . . . . 220--221
Igor Ivkovic and
Kostas Kontogiannis Model synchronization as a problem of
maximizing model dependencies . . . . . 222--223
Simon Holland Reflective composition: the declarative
composition of roles to unify objects,
roles, and aspects . . . . . . . . . . . 224--225
Paul V. Gestwicki and
Bharat Jayaraman JIVE: Java interactive visualization
environment . . . . . . . . . . . . . . 226--228
Matthew R. McBride The software architect: essence,
intuition, and guiding principles . . . 230--235
Steve Freeman and
Tim Mackinnon and
Nat Pryce and
Joe Walnes Mock roles, objects . . . . . . . . . . 236--246
Brian A. Berenbach Comparison of UML and text based
requirements engineering . . . . . . . . 247--252
Joseph A. Blotner PIP: a product planning strategy for the
whole family or\ldots how we became the
brady bunch . . . . . . . . . . . . . . 253--259
Aki Namioka and
Cary Bran eXtreme ISO ?!? . . . . . . . . . . . . 260--263
Daniel Antion Why reuse matters: ANI's digital archive
system . . . . . . . . . . . . . . . . . 264--267
Daniel L. Dvorak and
William K. Reinholtz Hard real-time: C++ versus RTSJ . . . . 268--274
Emerson R. Murphy-Hill and
Andrew P. Black Traits: experience with a language
feature . . . . . . . . . . . . . . . . 275--282
Olaf Zimmermann and
Sven Milinski and
Michael Craes and
Frank Oellermann Second generation Web services-oriented
architecture in production in the
finance industry . . . . . . . . . . . . 283--289
Joachim F. Kainz Migrating to simpler distributed
applications . . . . . . . . . . . . . . 290--293
Darrell Reimer and
Edith Schonberg and
Kavitha Srinivas and
Harini Srinivasan and
Julian Dolby and
Aaron Kershenbaum and
Larry Koved Validating structural properties of
nested objects . . . . . . . . . . . . . 294--304
Eric Bodden A lightweight LTL runtime verification
tool for Java . . . . . . . . . . . . . 306--307
Hadi Salimi NGMF: a generic framework for
constructing graph-based systems . . . . 308--309
Jing Zhang Supporting software evolution through
model-driven program transformation . . 310--311
Mircea Trofin A framework for removing redundant
context management services in
enterprise JavaBeans application servers 312--313
Suman Roychoudhury A language-independent approach to
software maintenance using grammar
adapters . . . . . . . . . . . . . . . . 314--315
Trevor Parsons A framework for detecting, assessing and
visualizing performance antipatterns in
component based systems . . . . . . . . 316--317
Raul Silaghi Refining designs along
middleware-specific concern-dimensions
at different MDA-levels of abstraction 318--319
Arvind S. Krishna Enhancing distributed object middleware
qualities . . . . . . . . . . . . . . . 320--321
Spiros Xanthos Identification of reusable components
within an object-oriented software
system using algebraic graph theory . . 322--323
Tao Xie Automatic identification of common and
special object-oriented unit tests . . . 324--325
Martin Keschenau Reverse engineering of UML
specifications from Java programs . . . 326--327
Lucas Layman Empirical investigation of the impact of
extreme programming practices on
software projects . . . . . . . . . . . 328--329
Lance Hammond and
Brian D. Carlstrom and
Vicky Wong and
Ben Hertzberg and
Mike Chen and
Christos Kozyrakis and
Kunle Olukotun Programming with transactional coherence
and consistency (TCC) . . . . . . . . . 1--13
Mihai Budiu and
Girish Venkataramani and
Tiberiu Chelcea and
Seth Copen Goldstein Spatial computation . . . . . . . . . . 14--26
Virantha Ekanayake and
Clinton Kelly and
IV and
Rajit Manohar An ultra low-power processor for sensor
networks . . . . . . . . . . . . . . . . 27--36
Christopher R. Lumb and
Richard Golding D-SPTF: decentralized request
distribution in brick-based storage
systems . . . . . . . . . . . . . . . . 37--47
Yasushi Saito and
Svend Fròlund and
Alistair Veitch and
Arif Merchant and
Susan Spence FAB: building distributed enterprise
disk arrays from commodity components 48--58
Timothy E. Denehy and
John Bent and
Florentina I. Popovici and
Andrea C. Arpaci-Dusseau and
Remzi H. Arpaci-Dusseau Deconstructing storage arrays . . . . . 59--71
Xiaotong Zhuang and
Tao Zhang and
Santosh Pande HIDE: an infrastructure for efficiently
protecting information leakage on the
address bus . . . . . . . . . . . . . . 72--84
G. Edward Suh and
Jae W. Lee and
David Zhang and
Srinivas Devadas Secure program execution via dynamic
information flow tracking . . . . . . . 85--96
Jaehyuk Huh and
Jichuan Chang and
Doug Burger and
Gurindar S. Sohi Coherence decoupling: making use of
incoherence . . . . . . . . . . . . . . 97--106
Srikanth T. Srinivasan and
Ravi Rajwar and
Haitham Akkary and
Amit Gandhi and
Mike Upton Continual flow pipelines . . . . . . . . 107--119
Rajagopalan Desikan and
Simha Sethumadhavan and
Doug Burger and
Stephen W. Keckler Scalable selective re-execution for EDGE
architectures . . . . . . . . . . . . . 120--132
John Regehr and
Alastair Reid HOIST: a system for automatically
deriving static analyzers for embedded
systems . . . . . . . . . . . . . . . . 133--143
Perry H. Wang and
Jamison D. Collins and
Hong Wang and
Dongkeun Kim and
Bill Greene and
Kai-Ming Chan and
Aamir B. Yunus and
Terry Sych and
Stephen F. Moore and
John P. Shen Helper threads via virtual
multithreading on an experimental
Itanium-2 processor-based platform . . . 144--155
Matthias Hauswirth and
Trishul M. Chilimbi Low-overhead memory leak detection using
adaptive statistical profiling . . . . . 156--164
Xipeng Shen and
Yutao Zhong and
Chen Ding Locality phase prediction . . . . . . . 165--176
Pin Zhou and
Vivek Pandey and
Jagadeesan Sundaresan and
Anand Raghuraman and
Yuanyuan Zhou and
Sanjeev Kumar Dynamic tracking of page miss ratio
curve for memory management . . . . . . 177--188
Rodric M. Rabbah and
Hariharan Sandanagobalane and
Mongkol Ekpanyapong and
Weng-Fai Wong Compiler orchestrated prefetching via
speculation and predication . . . . . . 189--198
Chen-Yong Cher and
Antony L. Hosking and
T. N. Vijaykumar Software prefetching for mark-sweep
garbage collection: hardware analysis
and software redesign . . . . . . . . . 199--210
David E. Lowell and
Yasushi Saito and
Eileen J. Samberg Devirtualizable virtual machines
enabling general, single-node, online
maintenance . . . . . . . . . . . . . . 211--223
Jared C. Smolens and
Brian T. Gold and
Jangwoo Kim and
Babak Falsafi and
James C. Hoe and
Andreas G. Nowatzyk Fingerprinting: bounding soft-error
detection latency and bandwidth . . . . 224--234
Greg Bronevetsky and
Daniel Marques and
Keshav Pingali and
Peter Szwed and
Martin Schulz Application-level checkpointing for
shared memory programs . . . . . . . . . 235--247
Qiang Wu and
Philo Juang and
Margaret Martonosi and
Douglas W. Clark Formal online methods for
voltage/frequency control in multiple
clock domain microprocessors . . . . . . 248--259
Mohamed Gomaa and
Michael D. Powell and
T. N. Vijaykumar Heat-and-run: leveraging SMT and CMP to
manage power density through the
operating system . . . . . . . . . . . . 260--270
Xiaodong Li and
Zhenmin Li and
Francis David and
Pin Zhou and
Yuanyuan Zhou and
Sarita Adve and
Sanjeev Kumar Performance directed energy management
for main memory and disks . . . . . . . 271--283
Anonymous Architecture . . . . . . . . . . . . . . ??
Anonymous Memory system analysis and optimization ??
Anonymous New models and architectures . . . . . . ??
Anonymous Potpourri . . . . . . . . . . . . . . . ??
Anonymous Power . . . . . . . . . . . . . . . . . ??
Anonymous Reliability . . . . . . . . . . . . . . ??
Anonymous Storage . . . . . . . . . . . . . . . . ??
Anonymous Security . . . . . . . . . . . . . . . . ??
Paul Frenger Forth and AI revisited: BRAIN.FORTH . . 11--16
Brian Cabana and
Suad Alagi\'c and
Jeff Faulkner Parametric polymorphism for Java: is
there any hope in sight? . . . . . . . . 22--31
Elliott Hughes Checking spelling in source code . . . . 32--38
James Noble and
Robert Biddle Notes on notes on postmodern programming 40--56
David West Looking for love (in all the wrong
places) . . . . . . . . . . . . . . . . 57--63
Brian Marick Methodology work is ontology work . . . 64--72
Munindar P. Singh and
Amit K. Chopra and
Nirmit Desai and
Ashok U. Mallya Protocols for processes: programming in
the large for open systems . . . . . . . 73--83
Jonathan Edwards Example centric programming . . . . . . 84--91
David Hovemeyer and
William Pugh Finding bugs is easy . . . . . . . . . . 92--106
Yinliang Zhao Granule-oriented programming . . . . . . 107--118
Tim Sheard Languages of the future . . . . . . . . 119--132
Anonymous Forth report . . . . . . . . . . . . . . ??
Anonymous OOPSLA onward! . . . . . . . . . . . . . ??
Manuel M. T. Chakravarty and
Gabriele Keller and
Simon Peyton Jones and
Simon Marlow Associated types with class . . . . . . 1--13
Richard Cobbe and
Matthias Felleisen Environmental acquisition revisited . . 14--25
Davide Ancona and
Ferruccio Damiani and
Sophia Drossopoulou and
Elena Zucca Polymorphic bytecode: compositional
compilation for Java-like languages . . 26--37
Juan Chen and
David Tarditi A simple typed intermediate language for
object-oriented languages . . . . . . . 38--49
Haruo Hosoya and
Alain Frisch and
Giuseppe Castagna Parametric polymorphism for XML . . . . 50--62
Eijiro Sumii and
Benjamin C. Pierce A bisimulation for type abstraction and
recursion . . . . . . . . . . . . . . . 63--74
Healfdene Goguen A syntactic approach to eta equality in
type theory . . . . . . . . . . . . . . 75--84
Dan R. Ghica Slot games: a quantitative model of
computation . . . . . . . . . . . . . . 85--97
Rajeev Alur and
Pavol \vCerný and
P. Madhusudan and
Wonhong Nam Synthesis of interface specifications
for Java classes . . . . . . . . . . . . 98--109
Cormac Flanagan and
Patrice Godefroid Dynamic partial-order reduction for
model checking software . . . . . . . . 110--121
Orna Grumberg and
Flavio Lerda and
Ofer Strichman and
Michael Theobald Proof-guided underapproximation-widening
for multi-process systems . . . . . . . 122--131
Andreas Podelski and
Andrey Rybalchenko Transition predicate abstraction and
fair termination . . . . . . . . . . . . 132--144
Simon J. Gay and
Rajagopal Nagarajan Communicating quantum processes . . . . 145--157
Peng Li and
Steve Zdancewic Downgrading policies and relaxed
noninterference . . . . . . . . . . . . 158--170
Sungwoo Park and
Frank Pfenning and
Sebastian Thrun A probabilistic language based upon
sampling functions . . . . . . . . . . . 171--182
Gareth Stoyle and
Michael Hicks and
Gavin Bierman and
Peter Sewell and
Iulian Neamtiu Mutatis mutandis: safe and predictable
dynamic software updating . . . . . . . 183--194
John Field and
Carlos A. Varela Transactors: a programming model for
maintaining globally consistent
distributed state in unreliable
environments . . . . . . . . . . . . . . 195--208
Roberto Bruni and
Hernán Melgratti and
Ugo Montanari Theoretical foundations for
compensations in flow composition
languages . . . . . . . . . . . . . . . 209--220
Matthias Neubauer and
Peter Thiemann From sequential programs to multi-tier
applications by program transformation 221--232
J. Nathan Foster and
Michael B. Greenwald and
Jonathan T. Moore and
Benjamin C. Pierce and
Alan Schmitt Combinators for bi-directional tree
transformations: a linguistic approach
to the view update problem . . . . . . . 233--246
Matthew Parkinson and
Gavin Bierman Separation logic and abstraction . . . . 247--258
Richard Bornat and
Cristiano Calcagno and
Peter O'Hearn and
Matthew Parkinson Permission accounting in separation
logic . . . . . . . . . . . . . . . . . 259--270
Cristiano Calcagno and
Philippa Gardner and
Uri Zarfaty Context logic and tree update . . . . . 271--282
John Tang Boyland and
William Retert Connecting effects and uniqueness with
adoption . . . . . . . . . . . . . . . . 283--295
Noam Rinetzky and
Jörg Bauer and
Thomas Reps and
Mooly Sagiv and
Reinhard Wilhelm A semantics for procedure local heaps
and its abstractions . . . . . . . . . . 296--309
Brian Hackett and
Radu Rugina Region-based shape analysis with tracked
locations . . . . . . . . . . . . . . . 310--323
Sumit Gulwani and
George C. Necula Precise interprocedural analysis using
random interpretation . . . . . . . . . 324--337
Denis Gopan and
Thomas Reps and
Mooly Sagiv A framework for numeric analysis of
array operations . . . . . . . . . . . . 338--350
Yichen Xie and
Alex Aiken Scalable error detection using boolean
satisfiability . . . . . . . . . . . . . 351--363
Sorin Lerner and
Todd Millstein and
Erika Rice and
Craig Chambers Automated soundness proofs for dataflow
analyses and transformations via local
rules . . . . . . . . . . . . . . . . . 364--377
Jeremy Manson and
William Pugh and
Sarita V. Adve The Java memory model . . . . . . . . . 378--391
Paul Frenger Tina: an improbable $3$-pin
microcontroller . . . . . . . . . . . . 5--10
Mihal Badjonski and
Mirjana Ivanovic and
Zoran Budimac Adaptable Java Agents (AJA): a tool for
programming of multi-agent systems . . . 17--26
Shujuan Jiang and
Baowen Xu An efficient and reliable
object-oriented exception handling
mechanism . . . . . . . . . . . . . . . 27--32
Sachin Shaw and
Pawan Kumar Loop-dead optimization . . . . . . . . . 33--40
A. Zerzelidis and
A. J. Wellings Requirements for a real-time .NET
framework . . . . . . . . . . . . . . . 41--50
Anonymous Forth . . . . . . . . . . . . . . . . . ??
Anonymous Technical correspondence . . . . . . . . ??
Viera K. Proulx and
Tanya Cashorali Calculator problem and the design recipe 4--11
Conrad Mueller Axiomatic computational model . . . . . 29--39
Yuqiang Xian and
Guangze Xiong Minimizing memory requirement of
real-time systems with concurrent
garbage collector . . . . . . . . . . . 40--48
Anonymous Circular patterns . . . . . . . . . . . ??
Paul Frenger Tired by Forth?: you should be! . . . . 5--8
Tetsuo Saitou and
Mitsugu Suzuki and
Tan Watanabe Dominance analysis of irreducible CFGs
by reduction . . . . . . . . . . . . . . 10--19
Simon Beloglavec and
Marjan Heri\vcko and
Matja\vz B. Juri\vc and
Ivan Rozman Analysis of the limitations of multiple
client handling in a Java server
environment . . . . . . . . . . . . . . 20--28
Matej \vCrepin\vsek and
Marjan Mernik and
Viljem \vZumer Extracting grammar from programs: brute
force approach . . . . . . . . . . . . . 29--38
Matej \vCrepin\vsek and
Marjan Mernik and
Faizan Javed and
Barrett R. Bryant and
Alan Sprague Extracting grammar from programs:
evolutionary approach . . . . . . . . . 39--46
P. van der Spek and
N. Plat and
C. Pronk Syntax error repair for a Java-based
parser generator . . . . . . . . . . . . 47--50
Patricio Buli\'c and
Veselko Gu\vstin An efficient way to filter out data
dependences with a sufficiently large
distance between memory references . . . 51--60
Robert Glück and
Masahiko Kawabe Revisiting an automatic program inverter
for Lisp . . . . . . . . . . . . . . . . 8--17
Rajeev Kumar and
Vikram Agrawal and
Anil Mangolia Realization of multimethods in single
dispatch object oriented languages . . . 18--27
Boris Sunik The specification language $T$ . . . . . 28--38
M. D. Derk Towards a simpler method of operational
semantics for language definition . . . 39--44
Manuel Barbosa and
Alcino Cunha and
Jorge Sousa Pinto Recursion patterns and time-analysis . . 45--54
Min Xu and
Rastislav Bodík and
Mark D. Hill A serializability violation detector for
shared-memory server programs . . . . . 1--14
Ben Liblit and
Mayur Naik and
Alice X. Zheng and
Alex Aiken and
Michael I. Jordan Scalable statistical bug isolation . . . 15--26
Tayfun Elmas and
Serdar Tasiran and
Shaz Qadeer VYRD: VerifYing concurrent programs by
runtime Refinement-violation Detection 27--37
Ranjit Jhala and
Rupak Majumdar Path slicing . . . . . . . . . . . . . . 38--47
David Mandelin and
Lin Xu and
Rastislav Bodík and
Doug Kimelman Jungloid mining: helping to navigate the
API jungle . . . . . . . . . . . . . . . 48--61
Michael Furr and
Jeffrey S. Foster Checking type safety of foreign function
calls . . . . . . . . . . . . . . . . . 62--72
Jeremy Siek and
Andrew Lumsdaine Essential language support for generic
programming . . . . . . . . . . . . . . 73--84
Brian Chin and
Shane Markstrum and
Todd Millstein Semantic type qualifiers . . . . . . . . 85--95
Neel Krishnaswami and
Jonathan Aldrich Permission-based ownership:
encapsulating state in higher-order
typed languages . . . . . . . . . . . . 96--106
Daniel A. Jiménez Code placement for improving dynamic
branch prediction accuracy . . . . . . . 107--116
Pavel Avgustinov and
Aske Simon Christensen and
Laurie Hendren and
Sascha Kuzins and
Jennifer Lhoták and
Ond\vrej Lhoták and
Oege de Moor and
Damien Sereni and
Ganesh Sittampalam and
Julian Tibble Optimising aspectJ . . . . . . . . . . . 117--128
Chris Lattner and
Vikram Adve Automatic pool allocation: improving
performance by controlling data
structure layout in the heap . . . . . . 129--142
Matthew Hertz and
Yi Feng and
Emery D. Berger Garbage collection without paging . . . 143--153
Hongbo Rong and
Alban Douillet and
Guang R. Gao Register allocation for software
pipelined multi-dimensional loops . . . 154--167
Xiaotong Zhuang and
Santosh Pande Differential register allocation . . . . 168--179
Alex Alet\`a and
Josep M. Codina and
Antonio Gonz\`alez and
David Kaeli Demystifying on-the-fly spill code . . . 180--189
Chi-Keung Luk and
Robert Cohn and
Robert Muth and
Harish Patil and
Artur Klauser and
Geoff Lowney and
Steven Wallace and
Vijay Janapa Reddi and
Kim Hazelwood Pin: building customized program
analysis tools with dynamic
instrumentation . . . . . . . . . . . . 190--200
Andrew Ayers and
Richard Schooler and
Chris Metcalf and
Anant Agarwal and
Junghwan Rhee and
Emmett Witchel TraceBack: first fault diagnosis by
reconstruction of distributed control
flow . . . . . . . . . . . . . . . . . . 201--212
Patrice Godefroid and
Nils Klarlund and
Koushik Sen DART: directed automated random testing 213--223
Michael K. Chen and
Xiao Feng Li and
Ruiqi Lian and
Jason H. Lin and
Lixia Liu and
Tao Liu and
Roy Ju Shangri-La: achieving high performance
from compiled network applications while
enabling ease of programming . . . . . . 224--236
Jinquan Dai and
Bo Huang and
Long Li and
Luddy Harrison Automatically partitioning packet
processing applications for pipelined
architectures . . . . . . . . . . . . . 237--248
Yang Ni and
Ulrich Kremer and
Adrian Stere and
Liviu Iftode Programming ad-hoc networks of mobile
and resource-constrained devices . . . . 249--260
Hans-J. Boehm Threads cannot be implemented as a
library . . . . . . . . . . . . . . . . 261--268
Carlos García Quiñones and
Carlos Madriles and
Jesús Sánchez and
Pedro Marcuello and
Antonio González and
Dean M. Tullsen Mitosis compiler: an infrastructure for
speculative threading based on
pre-computation slices . . . . . . . . . 269--279
Armando Solar-Lezama and
Rodric Rabbah and
Rastislav Bodík and
Kemal Ebcio\uglu Programming by sketching for
bit-streaming programs . . . . . . . . . 281--294
Kathleen Fisher and
Robert Gruber PADS: a domain-specific language for
processing ad hoc data . . . . . . . . . 295--304
Lujo Bauer and
Jay Ligatti and
David Walker Composing security policies with polymer 305--314
Franz Franchetti and
Yevgen Voronenko and
Markus Püschel Formal loop merging for signal
transforms . . . . . . . . . . . . . . . 315--326
Ruibin Xu and
Dakai Zhu and
Cosmin Rusu and
Rami Melhem and
Daniel Mossé Energy-efficient policies for embedded
clusters . . . . . . . . . . . . . . . . 1--10
Kun Zhang and
Santosh Pande Efficient application migration under
compiler guidance . . . . . . . . . . . 10--20
Thomas A. Henzinger and
Christoph M. Kirsch and
Slobodan Matic Composable code generation for
distributed giotto . . . . . . . . . . . 21--30
Emilia Farcas and
Claudiu Farcas and
Wolfgang Pree and
Josef Templ Transparent distribution of real-time
components based on logical execution
time . . . . . . . . . . . . . . . . . . 31--39
David Gay and
Phil Levis and
David Culler Software design patterns for TinyOS . . 40--49
John Regehr and
Usit Duongsaa Preventing interrupt overload . . . . . 50--58
Ben L. Titzer and
Jens Palsberg Nonintrusive precision instrumentation
of microcontroller software . . . . . . 59--68
Keith D. Cooper and
Alexander Grosul and
Timothy J. Harvey and
Steven Reeves and
Devika Subramanian and
Linda Torczon and
Todd Waterman ACME: adaptive compilation made
efficient . . . . . . . . . . . . . . . 69--77
Björn Franke and
Michael O'Boyle and
John Thomson and
Grigori Fursin Probabilistic source-level optimisation
of embedded programs . . . . . . . . . . 78--86
Hitoshi Oi On the design of the local variable
cache in a hardware translation-based
Java Virtual Machine . . . . . . . . . . 87--94
Dominique Chanet and
Bjorn De Sutter and
Bruno De Bus and
Ludo Van Put and
Koen De Bosschere System-wide compaction and
specialization of the Linux kernel . . . 95--104
Philip Brisk and
Jamie Macbeth and
Ani Nahapetian and
Majid Sarrafzadeh A dictionary construction technique for
code compression systems with echo
instructions . . . . . . . . . . . . . . 105--114
Janis Sermulins and
William Thies and
Rodric Rabbah and
Saman Amarasinghe Cache aware optimization of stream
programs . . . . . . . . . . . . . . . . 115--126
Peter G. Sassone and
D. Scott Wills and
Gabriel H. Loh Static strands: safely collapsing
dependence chains for increasing
embedded power efficiency . . . . . . . 127--136
Won So and
Alexander G. Dean Complementing software pipelining with
software thread integration . . . . . . 137--146
Alexei Kudriavtsev and
Peter Kogge Generation of permutations for SIMD
processors . . . . . . . . . . . . . . . 147--156
Jan Staschulat and
Rolf Ernst Scalable precision cache analysis for
preemptive scheduling . . . . . . . . . 157--165
Rong Xu and
Zhiyuan Li A sample-based cache mapping scheme . . 166--174
Yudong Tan and
Vincent J. Mooney and
III WCRT analysis for a uniprocessor with a
unified prioritized cache . . . . . . . 175--182
David F. Bacon and
Perry Cheng and
David Grove and
Martin T. Vechev Syncopation: generational real-time
garbage collection in the metronome . . 183--192
Tobias Mann and
Morgan Deters and
Rob LeGrand and
Ron K. Cytron Static determination of allocation rates
to support real-time garbage collection 193--202
Yifan Zhu and
Frank Mueller Feedback EDF scheduling exploiting
hardware-assisted asynchronous dynamic
voltage scaling . . . . . . . . . . . . 203--212
Mahmut Kandemir and
Guangyu Chen and
Ismail Kadayif Compiling for memory emergency . . . . . 213--221
Delvin C. Defoe and
Sharath R. Cholleti and
Ron K. Cytron Upper bound for defragmenting buddy
heaps . . . . . . . . . . . . . . . . . 222--229
Paul Griffin and
Witawas Srisa-an and
J. Morris Chang An energy efficient garbage collector
for Java embedded devices . . . . . . . 230--238
Paul Frenger Forth sorts fruit down under . . . . . . 7--10
Jeff Furlong and
Atanas Radenski Handling the subclassing anomaly with
Object Teams . . . . . . . . . . . . . . 12--18
Saso Greiner and
Damijan Rebernak and
Janez Brest and
Viljem Zumer Z0 --- a tiny experimental language . . 19--28
Dirk Draheim and
Christof Lutteroth and
Gerald Weber Generative programming for C# . . . . . 29--33
Shujuan Jiang and
Yongping Zhang and
Dashun Yan and
Yuanpeng Jiang An approach to automatic testing
exception handling . . . . . . . . . . . 34--39
François Pottier From ML type inference to stratified
type inference . . . . . . . . . . . . . 1--1
Olin Shivers The anatomy of a loop: a story of scope
and control . . . . . . . . . . . . . . 2--14
Peter Sewell and
James J. Leifer and
Keith Wansbrough and
Francesco Zappa Nardelli and
Mair Allen-Williams and
Pierre Habouzit and
Viktor Vafeiadis Acute: high-level programming language
design for distributed computation . . . 15--26
Norman Ramsey and
Kathleen Fisher and
Paul Govereau An expressive language of signatures . . 27--40
Derek Dreyer Recursive type generativity . . . . . . 41--53
Henrik Nilsson Dynamic optimization for functional
reactive programming using generalized
algebraic data types . . . . . . . . . . 54--65
Chiyan Chen and
Hongwei Xi Combining programming with theorem
proving . . . . . . . . . . . . . . . . 66--77
Amal Ahmed and
Matthew Fluet and
Greg Morrisett A step-indexed model of substructural
state . . . . . . . . . . . . . . . . . 78--91
Michael F. Ringenburg and
Dan Grossman AtomCaml: first-class atomicity via
rollback . . . . . . . . . . . . . . . . 92--104
Tachio Terauchi and
Alex Aiken Witnessing side-effects . . . . . . . . 105--115
Thomas Hallgren and
Mark P. Jones and
Rebekah Leslie and
Andrew Tolmach A principled approach to operating
system construction in Haskell . . . . . 116--128
Brendan Eich JavaScript at ten years . . . . . . . . 129--129
Didier Rémy Simple, partial type-inference for
System F based on type-containment . . . 130--143
Daan Leijen and
Andres Löh Qualified types for MLF . . . . . . . . 144--155
Henning Makholm and
J. B. Wells Type inference, principal typings, and
let-polymorphism for first-class mixin
modules . . . . . . . . . . . . . . . . 156--167
Iavor S. Diatchki and
Mark P. Jones and
Rebekah Leslie High-level views on low-level
representations . . . . . . . . . . . . 168--179
James Cheney Scrap your nameplate: (functional pearl) 180--191
Oleg Kiselyov and
Chung-chieh Shan and
Daniel P. Friedman and
Amr Sabry Backtracking, interleaving, and
terminating monad transformers:
(functional pearl) . . . . . . . . . . . 192--203
Ralf Lämmel and
Simon Peyton Jones Scrap your boilerplate with class:
extensible generic functions . . . . . . 204--215
Greg Pettyjohn and
John Clements and
Joe Marshall and
Shriram Krishnamurthi and
Matthias Felleisen Continuations from generalized stack
inspection . . . . . . . . . . . . . . . 216--227
J. Guadalupe Ramos and
Josep Silva and
Germán Vidal Fast narrowing-driven partial evaluation
for inductively sequential programs . . 228--239
Robert Harper Mechanizing the meta-theory of
programming languages . . . . . . . . . 240--240
Manuel M. T. Chakravarty and
Gabriele Keller and
Simon Peyton Jones Associated type synonyms . . . . . . . . 241--253
Xinyu Feng and
Zhong Shao Modular verification of concurrent
assembly code with dynamic thread
creation and termination . . . . . . . . 254--267
Edwin Westbrook and
Aaron Stump and
Ian Wehrman A language-based approach to
functionally correct imperative
programming . . . . . . . . . . . . . . 268--279
Martin Berger and
Kohei Honda and
Nobuko Yoshida A logical analysis of aliasing in
imperative higher-order functions . . . 280--293
Neil Ghani and
Patricia Johann and
Tarmo Uustalu and
Varmo Vene Monadic augment and generalised short
cut fusion . . . . . . . . . . . . . . . 294--305
Daniel S. Dantas and
David Walker and
Geoffrey Washburn and
Stephanie Weirich PolyAML: a polymorphic aspect-oriented
functional programming language . . . . 306--319
Hidehiko Masuhara and
Hideaki Tatsuzawa and
Akinori Yonezawa Aspectual Caml: an aspect-oriented
functional language . . . . . . . . . . 320--330
Jaakko Järvi and
Jeremiah Willcock and
Andrew Lumsdaine Associated types and constraint
propagation for mainstream
object-oriented generics . . . . . . . . 1--19
Andrew Kennedy and
Claudio V. Russo Generalized algebraic data types and
object-oriented programming . . . . . . 21--40
Martin Odersky and
Matthias Zenger Scalable component abstractions . . . . 41--57
Manu Sridharan and
Denis Gopan and
Lexin Shan and
Rastislav Bodík Demand-driven points-to analysis for
Java . . . . . . . . . . . . . . . . . . 59--76
Mangala Gowri Nanda and
Christian Grothoff and
Satish Chandra Deriving object typestates in the
presence of inter-object references . . 77--96
Joseph (Yossi) Gil and
Itay Maman Micro patterns in Java code . . . . . . 97--116
J. Andrés Díaz-Pace and
Marcelo R. Campo ArchMatE: from architectural styles to
object-oriented models through
exploratory tool support . . . . . . . . 117--132
Uwe Zdun and
Paris Avgeriou Modeling architectural patterns using
architectural primitives . . . . . . . . 133--146
Cosmin E. Oancea and
Stephen M. Watt Parametric polymorphism for software
component architectures . . . . . . . . 147--166
Neeraj Sangal and
Ev Jordan and
Vineet Sinha and
Daniel Jackson Using dependency models to manage
complex software architecture . . . . . 167--176
Alexandre Bergel and
Stéphane Ducasse and
Oscar Nierstrasz Classbox/J: controlling the scope of
change in Java . . . . . . . . . . . . . 177--189
Yu David Liu and
Scott F. Smith Interaction-based programming with
classages . . . . . . . . . . . . . . . 191--209
Matthew S. Tschantz and
Michael D. Ernst Javari: adding reference immutability to
Java . . . . . . . . . . . . . . . . . . 211--230
Kathryn E. Gray and
Robert Bruce Findler and
Matthew Flatt Fine-grained interoperability through
mirrors and contracts . . . . . . . . . 231--245
Sergei Kojarski and
David H. Lorenz Pluggable AOP: designing aspect
mechanisms for third-party composition 247--263
Ittai Balaban and
Frank Tip and
Robert Fuhrer Refactoring support for class library
migration . . . . . . . . . . . . . . . 265--279
Matthias Hauswirth and
Amer Diwan and
Peter F. Sweeney and
Michael C. Mozer Automating vertical profiling . . . . . 281--296
Matthew Arnold and
Adam Welc and
V. T. Rajan Improving virtual machine performance
using a cross-run profile repository . . 297--311
Matthew Hertz and
Emery D. Berger Quantifying the performance of garbage
collection vs. explicit memory
management . . . . . . . . . . . . . . . 313--326
Ajeet Shankar and
S. Subramanya Sastry and
Rastislav Bodík and
James E. Smith Runtime specialization with optimistic
heap analysis . . . . . . . . . . . . . 327--343
Chris Allan and
Pavel Avgustinov and
Aske Simon Christensen and
Laurie Hendren and
Sascha Kuzins and
Ond\vrej Lhoták and
Oege de Moor and
Damien Sereni and
Ganesh Sittampalam and
Julian Tibble Adding trace matching with free
variables to AspectJ . . . . . . . . . . 345--364
Michael Martin and
Benjamin Livshits and
Monica S. Lam Finding application errors and security
flaws using PQL: a program query
language . . . . . . . . . . . . . . . . 365--383
Simon Goldsmith and
Robert O'Callahan and
Alex Aiken Relational queries over program traces 385--402
Alexander Ahern and
Nobuko Yoshida Formalising Java RMI with explicit code
mobility . . . . . . . . . . . . . . . . 403--422
Douglas Gregor and
Andrew Lumsdaine Lifting sequential graph algorithms for
distributed-memory parallel computation 423--437
Adam Welc and
Suresh Jagannathan and
Antony Hosking Safe futures for Java . . . . . . . . . 439--453
Marko van Dooren and
Eric Steegmans Combining the robustness of checked
exceptions with the flexibility of
unchecked exceptions using anchored
exception declarations . . . . . . . . . 455--471
Yanhong A. Liu and
Scott D. Stoller and
Michael Gorbovitski and
Tom Rothamel and
Yanni Ellen Liu Incrementalization across object
abstraction . . . . . . . . . . . . . . 473--486
Antonio Cunei and
Jan Vitek PolyD: a flexible dispatching framework 487--503
Jonathan Edwards Subtext: uncovering the simplicity of
programming . . . . . . . . . . . . . . 505--518
Philippe Charles and
Christian Grothoff and
Vijay Saraswat and
Christopher Donawa and
Allan Kielstra and
Kemal Ebcioglu and
Christoph von Praun and
Vivek Sarkar X10: an object-oriented approach to
non-uniform cluster computing . . . . . 519--538
Glenn Vanderburg A simple model of agile software
processes --- or --- extreme programming
annealed . . . . . . . . . . . . . . . . 539--545
Paul Frenger Forth report: Ten years of Forth in ACM
Sigplan Notices: part 1 . . . . . . . . 4--16
Chandan Kumar Behera and
Pawan Kumar An improved algorithm for loop dead
optimization . . . . . . . . . . . . . . 18--28
Bixin Li and
Ying Zhou and
Yancheng Wang and
Junhui Mo Matrix-based component dependence
representation and its applications in
software quality assurance . . . . . . . 29--36
Robert M. Siegfried and
Denis Diakoniarakis and
Kenneth G. Franqueiro and
Amol Jain Extending a scripting language for
Visual Basic forms . . . . . . . . . . . 37--40
A. Savidis More dynamic imperative languages . . . 6--13
Rajeev Kumar and
Amit Gupta and
B. S. Pankaj and
Mrinmoy Ghosh and
P. P. Chakrabarti Post-compilation optimization for
multiple gains with pattern matching . . 14--23
Raghavendra Rao Loka Hybrid compilation: a case study . . . . 24--27
José L. Sierra and
Antonio Navarro and
Baltasar Fernández-Manjón and
Alfredo Fernández-Valmayor Incremental definition and
operationalization of domain-specific
markup languages in ADDS . . . . . . . . 28--37
James McKinna Why dependent types matter . . . . . . . 1--1
Kathleen Fisher and
Yitzhak Mandelbaum and
David Walker The next 700 data description languages 2--15
Chengliang Zhang and
Chen Ding and
Mitsunori Ogihara and
Yutao Zhong and
Youfeng Wu A hierarchical model of data locality 16--29
Gautam and
S. Rajopadhye Simplifying reductions . . . . . . . . . 30--41
Xavier Leroy Formal certification of a compiler
back-end or: programming a compiler with
a proof assistant . . . . . . . . . . . 42--54
Steve Bishop and
Matthew Fairbairn and
Michael Norrish and
Peter Sewell and
Michael Smith and
Keith Wansbrough Engineering with logic: HOL
specification and symbolic-evaluation
testing for TCP implementations . . . . 55--66
Mads Dam Decidability and proof systems for
language-based noninterference relations 67--78
Sebastian Hunt and
David Sands On flow-sensitive security types . . . . 79--90
Torben Amtoft and
Sruthi Bandhakavi and
Anindya Banerjee A logic for information flow in
object-oriented programs . . . . . . . . 91--102
Jérôme Vouillon Polymorphic regular tree types and
patterns . . . . . . . . . . . . . . . . 103--114
Shuvendu K. Lahiri and
Shaz Qadeer Verifying properties of well-founded
linked lists . . . . . . . . . . . . . . 115--126
Matthew Might and
Olin Shivers Environment analysis via $\Delta$CFA . . 127--140
Vasileios Koutavas and
Mitchell Wand Small bisimulations for reasoning about
higher-order imperative programs . . . . 141--152
Rajeev Alur and
Swarat Chaudhuri and
P. Madhusudan A fixpoint calculus for local and global
program flows . . . . . . . . . . . . . 153--165
Martin Odersky The Scala experiment: can we provide
better language support for component
systems? . . . . . . . . . . . . . . . . 166--167
Norman Danner and
James S. Royer Adventures in time and space . . . . . . 168--179
Albert Cohen and
Marc Duranton and
Christine Eisenbeis and
Claire Pagetti and
Florence Plateau and
Marc Pouzet $N$-synchronous Kahn networks: a relaxed
model of synchrony for real-time systems 180--193
Guangyu Chen and
Feihui Li and
Mahmut Kandemir Compiler-directed channel allocation for
saving power in on-chip networks . . . . 194--205
Nils Anders Danielsson and
John Hughes and
Patrik Jansson and
Jeremy Gibbons Fast and loose reasoning is morally . . 206--217
Philippe Meunier and
Robert Bruce Findler and
Matthias Felleisen Modular set-based analysis from
contracts . . . . . . . . . . . . . . . 218--231
François Pottier and
Yann Régis-Gianas Stratified type inference for
generalized algebraic data types . . . . 232--244
Cormac Flanagan Hybrid type checking . . . . . . . . . . 245--256
Ik-Soon Kim and
Kwangkeun Yi and
Cristiano Calcagno A polymorphic modal type system for
Lisp-like multi-staged languages . . . . 257--268
Tim Sweeney The next mainstream programming
language: a game developer's perspective 269--269
Erik Ernst and
Klaus Ostermann and
William R. Cook A virtual class calculus . . . . . . . . 270--282
Jed Liu and
Aaron Kimball and
Andrew C. Myers Interruptible iterators . . . . . . . . 283--294
Gabriel Dos Reis and
Bjarne Stroustrup Specifying C++ concepts . . . . . . . . 295--308
Hayo Thielecke Frame rules from answer types for code
pointers . . . . . . . . . . . . . . . . 309--319
Zhaozhong Ni and
Zhong Shao Certified assembly programming with
embedded code pointers . . . . . . . . . 320--333
Mandana Vaziri and
Frank Tip and
Julian Dolby Associating synchronization constraints
with data in an object-oriented language 334--345
Bill McCloskey and
Feng Zhou and
David Gay and
Eric Brewer Autolocker: synchronization inference
for atomic sections . . . . . . . . . . 346--358
Yi Lu and
John Potter Protecting representation with effect
encapsulation . . . . . . . . . . . . . 359--371
Zhendong Su and
Gary Wassermann The essence of command injection attacks
in Web applications . . . . . . . . . . 372--382
Daniel S. Dantas Harmless advice . . . . . . . . . . . . 383--396
Vijay S. Menon and
Neal Glew and
Brian R. Murphy and
Andrew McCreight and
Tatiana Shpeisman and
Ali-Reza Adl-Tabatabai and
Leaf Petersen A verifiable SSA program representation
for aggressive compiler optimization . . 397--408
Reuben Olinsky and
Christian Lindig and
Norman Ramsey Staged allocation: a compositional
technique for specifying and
implementing procedure calling
conventions . . . . . . . . . . . . . . 409--421
Deyi Xue Developing a superset language of
Smalltalk for modeling distributed
mechanical design systems . . . . . . . 8--17
Kallol Borah Indus: an object oriented language for
Ubiquitous computing . . . . . . . . . . 18--24
Anonymous MxYacc: parser generator for mixed
languages . . . . . . . . . . . . . . . 25--28
Mike Murphy Some suggestions for the use of tables
in compilers . . . . . . . . . . . . . . 29--33
Mark W. Bailey and
John Hatcliff and
Frank Tip PEPM 2006 paper abstracts . . . . . . . 4--8
D. Janakiram and
R. Venkateswarlu and
A. Vijay Srinivas and
A. Uday Kumar Soma: a compositional language for
distributed systems . . . . . . . . . . 10--19
Zhang Ning and
Guangze Xiong Minimizing GC work by analysis of live
objects . . . . . . . . . . . . . . . . 20--29
Anthony H. Dekker Lazy functional programming in Java . . 30--39
Byeong-Mo Chang Static check analysis for Java stack
inspection . . . . . . . . . . . . . . . 40--48
Paul Frenger Ten years of Forth in ACM Sigplan
Notices: part 2 . . . . . . . . . . . . 3--14
Paul B. Mann A translational BNF grammar notation
(TBNF) . . . . . . . . . . . . . . . . . 16--23
Dillip Kumar Lenka and
Pawan Kumar States merging in LR parser . . . . . . 24--29
Shujuan Jiang and
Baowen Xu and
Liang Shi An approach to analyzing recursive
programs with exception handling
constructs . . . . . . . . . . . . . . . 30--35
Javier Tuya and
M. José Suárez-Cabal and
Claudio de la Riva A practical guide to SQL white-box
testing . . . . . . . . . . . . . . . . 36--41
Raghavendra Rao Loka Compilation reuse and hybrid
compilation: an experiment . . . . . . . 42--49
Chandan Kumar Behera and
Pawan Kumar An improved algorithm for loop dead
optimization . . . . . . . . . . . . . . 11--20
Sewon Moon and
Byeong-Mo Chang A thread monitoring system for
multithreaded Java programs . . . . . . 21--29
Yingzhou Zhang and
Jose Emilio Labra Gayo and
Agustín Cernuda del Río A monadic program slicer . . . . . . . . 30--38
Michael D. Adams and
David S. Wise Fast additions on masked integers . . . 39--45
Richard A. Frost and
Rahmatullah Hafiz A new top-down parsing algorithm to
accommodate ambiguity and left recursion
in polynomial time . . . . . . . . . . . 46--54
Brian D. Carlstrom and
Austen McDonald and
Hassan Chafi and
JaeWoong Chung and
Chi Cao Minh and
Christos Kozyrakis and
Kunle Olukotun The ATOMOS transactional programming
language . . . . . . . . . . . . . . . . 1--13
Tim Harris and
Mark Plesko and
Avraham Shinnar and
David Tarditi Optimizing memory transactions . . . . . 14--25
Ali-Reza Adl-Tabatabai and
Brian T. Lewis and
Vijay Menon and
Brian R. Murphy and
Bratin Saha and
Tatiana Shpeisman Compiler and runtime support for
efficient software transactional memory 26--37
Robert Grimm Better extensibility through modular
syntax . . . . . . . . . . . . . . . . . 38--51
M. Anton Ertl and
Kevin Casey and
David Gregg Fast and flexible instruction selection
with on-demand tree-parsing automata . . 52--60
Spyridon Triantafyllis and
Matthew J. Bridges and
Easwaran Raman and
Guilherme Ottoni and
David I. August A framework for unrestricted
whole-program optimization . . . . . . . 61--71
Iulian Neamtiu and
Michael Hicks and
Gareth Stoyle and
Manuel Oriol Practical dynamic software updating for
C . . . . . . . . . . . . . . . . . . . 72--83
Long Fei and
Samuel P. Midkiff Artemis: practical runtime monitoring of
applications for execution anomalies . . 84--95
Umut A. Acar and
Guy E. Blelloch and
Matthias Blume and
Kanat Tangwongsan An experimental analysis of
self-adjusting computation . . . . . . . 96--107
Christopher Barton and
C\'Clin Casçaval and
George Almási and
Yili Zheng and
Montse Farreras and
Siddhartha Chatterje and
José Nelson Amaral Shared memory programming for large
scale machines . . . . . . . . . . . . . 108--117
Gang Ren and
Peng Wu and
David Padua Optimizing data permutations for SIMD
devices . . . . . . . . . . . . . . . . 118--131
Dorit Nuzman and
Ira Rosen and
Ayal Zaks Auto-vectorization of interleaved data
for SIMD . . . . . . . . . . . . . . . . 132--143
Dinakar Dhurjati and
Sumant Kowshik and
Vikram Adve SAFECode: enforcing alias analysis for
weakly typed languages . . . . . . . . . 144--157
Emery D. Berger and
Benjamin G. Zorn DieHard: probabilistic memory safety for
unsafe languages . . . . . . . . . . . . 158--168
Xiangyu Zhang and
Neelam Gupta and
Rajiv Gupta Pruning dynamic slices with confidence 169--180
Troy A. Johnson and
Rudolf Eigenmann Context-sensitive domain-independent
algorithm composition and selection . . 181--192
Guangyu Chen and
Feihui Li and
Mahmut Kandemir and
Mary Jane Irwin Reducing NoC energy consumption through
compiler-directed channel voltage
scaling . . . . . . . . . . . . . . . . 193--203
David Ryan Koes and
Seth Copen Goldstein A global progressive register allocator 204--215
Takuya Nakaike and
Tatsushi Inagaki and
Hideaki Komatsu and
Toshio Nakatani Profile-based global live-range
splitting . . . . . . . . . . . . . . . 216--227
Matthew J. Bridges and
Neil Vachharajani and
Guilherme Ottoni and
David I. August Automatic instruction scheduler
retargeting by reverse-engineering . . . 228--238
Jeremy Lau and
Matthew Arnold and
Michael Hind and
Brad Calder Online performance auditing: using hot
optimizations without getting burned . . 239--251
Trishul M. Chilimbi and
Ran Shaham Cache-conscious coallocation of hot data
streams . . . . . . . . . . . . . . . . 252--262
Xiaotong Zhuang and
Mauricio J. Serrano and
Harold W. Cain and
Jong-Deok Choi Accurate, efficient, and adaptive
calling context profiling . . . . . . . 263--271
Jaakko Järvi and
Douglas Gregor and
Jeremiah Willcock and
Andrew Lumsdaine and
Jeremy Siek Algorithm specialization in generic
programming: challenges of constrained
generics in C++ . . . . . . . . . . . . 272--282
Jaakko Järvi and
Douglas Gregor and
Jeremiah Willcock and
Andrew Lumsdaine and
Jeremy Siek Algorithm specialization in generic
programming: challenges of constrained
generics in C++ . . . . . . . . . . . . 272--282
Daniel Spoonhower and
Joshua Auerbach and
David F. Bacon and
Perry Cheng and
David Grove Eventrons: a safe programming construct
for high-frequency hard real-time
applications . . . . . . . . . . . . . . 283--294
Olin Shivers and
Matthew Might Continuations and transducer composition 295--307
Mayur Naik and
Alex Aiken and
John Whaley Effective static race detection for Java 308--319
Polyvios Pratikakis and
Jeffrey S. Foster and
Michael Hicks LOCKSMITH: context-sensitive correlation
analysis for race detection . . . . . . 320--331
Wen-ke Chen and
Sanjay Bhansali and
Trishul Chilimbi and
Xiaofeng Gao and
Weihaw Chuang Profile-guided proactive garbage
collection for locality optimization . . 332--340
Martin T. Vechev and
Eran Yahav and
David F. Bacon Correctness-preserving derivation of
concurrent garbage collection algorithms 341--353
Haim Kermany and
Erez Petrank The Compressor: concurrent, incremental,
and parallel compaction . . . . . . . . 354--363
Samuel Z. Guyer and
Kathryn S. McKinley and
Daniel Frampton Free-Me: a static analysis for automatic
individual object reclamation . . . . . 364--375
Sumit Gulwani and
Ashish Tiwari Combining abstract interpreters . . . . 376--386
Manu Sridharan and
Rastislav Bodík Refinement-based context-sensitive
points-to analysis for Java . . . . . . 387--400
Xinyu Feng and
Zhong Shao and
Alexander Vaynberg and
Sen Xiang and
Zhaozhong Ni Modular verification of assembly code
with stack-based control abstractions 401--414
Byron Cook and
Andreas Podelski and
Andrey Rybalchenko Termination proofs for systems code . . 415--426
Margaret Martonosi Embedded systems in the wild: ZebraNet
software, hardware, and deployment
experiences . . . . . . . . . . . . . . 1--1
Carl von Platen and
Johan Eker Feedback linking: optimizing object code
layout for updates . . . . . . . . . . . 2--11
Kun Zhang and
Santosh Pande Minimizing downtime in seamless
migrations of mobile applications . . . 12--21
Michal Spivak and
Sivan Toledo Storing a persistent transactional
object heap on flash memory . . . . . . 22--33
John Regehr and
Usit Duongsaa Deriving abstract transfer functions for
analyzing embedded software . . . . . . 34--43
Nathan Cooprider and
John Regehr Pluggable abstract domains for analyzing
embedded software . . . . . . . . . . . 44--53
Antoine Miné Field-sensitive value analysis of
embedded C programs with union types and
pointer arithmetics . . . . . . . . . . 54--63
William Kreahling and
Stephen Hines and
David Whalley and
Gary Tyson Reducing the cost of conditional
transfers of control by using comparison
specifications . . . . . . . . . . . . . 64--71
Xiaotong Zhuang and
Santosh Pande Effective thread management on network
processors with compiler analysis . . . 72--82
Prasad A. Kulkarni and
David B. Whalley and
Gary S. Tyson and
Jack W. Davidson In search of near-optimal optimization
phase orderings . . . . . . . . . . . . 83--92
Klaus Danne and
Marco Platzner An EDF schedulability test for periodic
tasks on reconfigurable hardware devices 93--102
Christer Sandberg and
Andreas Ermedahl and
Jan Gustafsson and
Björn Lisper Faster WCET flow analysis by program
slicing . . . . . . . . . . . . . . . . 103--112
Steffen Prochnow and
Claus Traulsen and
Reinhard von Hanxleden Synthesizing safe state machines from
Esterel . . . . . . . . . . . . . . . . 113--124
Stephen A. Edwards and
Olivier Tardieu Efficient code generation from SHIM
models . . . . . . . . . . . . . . . . . 125--134
Tom Rothamel and
Yanhong A. Liu and
Constance L. Heitmeyer and
Elizabeth I. Leonard Generating optimized code from SCR
specifications . . . . . . . . . . . . . 135--144
Stefan Farfeleder and
Andreas Krall and
Edwin Steiner and
Florian Brandner Effective compiler generation by
architecture description . . . . . . . . 145--152
Jian-Jia Chen and
Tei-Wei Kuo Procrastination for leakage-aware
rate-monotonic scheduling on a dynamic
voltage scaling processor . . . . . . . 153--162
Madhu Mutyam and
Feihui Li and
Vijaykrishnan Narayanan and
Mahmut Kandemir and
Mary Jane Irwin Compiler-directed thermal management for
VLIW functional units . . . . . . . . . 163--172
Sanghyun Park and
Aviral Shrivastava and
Nikil Dutt and
Alex Nicolau and
Yunheung Paek and
Eugene Earlie Bypass aware instruction scheduling for
register file power reduction . . . . . 173--181
Leipo Yan and
Thambipillai Srikanthan and
Niu Gang Area and delay estimation for FPGA
implementation of coarse-grained
reconfigurable architectures . . . . . . 182--188
Raju Pandey and
Jeffrey Wu BOTS: a constraint-based component
system for synthesizing scalable
software systems . . . . . . . . . . . . 189--198
Weihua Zhang and
Xinglong Qian and
Ye Wang and
Binyu Zang and
Chuanqi Zhu Optimizing compiler for shared-memory
multiple SIMD architecture . . . . . . . 199--208
Robert Bruce Findler Scheme and Functional Programming 2006:
paper abstracts . . . . . . . . . . . . 6--9
Paul Frenger Book review: Designing Embedded Hardware 10--14
Ben Denckla Many cyclic block diagrams do not need
parallel semantics . . . . . . . . . . . 16--20
Dibyendu Das Optimizing subroutines with optional
parameters in F90 via function cloning 21--28
Fuh-Gwo Chen and
Ting-Wei Hou Instruction-coated translation: an
approach to restructure directly
threaded interpreters with low cohesion 29--33
J. Ángel Velázquez-Iturbide Principled design of logical fisheye
views of functional expressions . . . . 34--43
R. Kent Dybvig The development of Chez Scheme . . . . . 1--12
Matthew Might and
Olin Shivers Improving flow analyses via $\Gamma$CFA:
abstract garbage collection and counting 13--25
Oleg Kiselyov and
Chung-chieh Shan and
Amr Sabry Delimited dynamic binding . . . . . . . 26--37
David Walker and
Lester Mackey and
Jay Ligatti and
George A. Reis and
David I. August Static typing for a faulty lambda
calculus . . . . . . . . . . . . . . . . 38--49
Simon Peyton Jones and
Dimitrios Vytiniotis and
Stephanie Weirich and
Geoffrey Washburn Simple unification-based type inference
for GADTs . . . . . . . . . . . . . . . 50--61
Aleksandar Nanevski and
Greg Morrisett and
Lars Birkedal Polymorphism and separation in Hoare
type theory . . . . . . . . . . . . . . 62--73
Keiko Nakata and
Jacques Garrigue Recursive modules for programming . . . 74--86
Scott Owens and
Matthew Flatt From structures and functors to modules
and units . . . . . . . . . . . . . . . 87--98
Andreas Rossberg The missing link: dynamic components for
ML . . . . . . . . . . . . . . . . . . . 99--110
David Fisher and
Olin Shivers Static analysis for syntax objects . . . 111--121
Marc Shapiro Practical proofs of concurrent programs 123--123
Kevin Donnelly and
Matthew Fluet Transactional events . . . . . . . . . . 124--135
Lukasz Ziarek and
Philip Schatz and
Suresh Jagannathan Stabilizers: a modular checkpointing
abstraction for concurrent functional
programs . . . . . . . . . . . . . . . . 136--147
Malcolm Dowse and
Andrew Butterfield Modelling deterministic concurrent I/O 148--159
Adam Chlipala Modular development of certified program
verifiers with a proof assistant . . . . 160--171
Jason Hickey and
Aleksey Nogin and
Xin Yu and
Alexei Kopylov Mechanized meta-reasoning using a hybrid
HOAS/de Bruijn representation and
reflection . . . . . . . . . . . . . . . 172--183
Grigore Ro\csu Equality of streams is a $\Pi 0$ over
$2$-complete problem . . . . . . . . . . 184--191
Alain Frisch OCaml + XDuce . . . . . . . . . . . . . 192--200
Shinya Kawanaka and
Haruo Hosoya biXid: a bidirectional transformation
language for XML . . . . . . . . . . . . 201--214
Richard S. Bird Fifteen years of functional pearls . . . 215--215
Björn Bringert and
Aarne Ranta A pattern for almost compositional
functions . . . . . . . . . . . . . . . 216--226
Shin-ya Katsumata and
Susumu Nishimura Algebraic fusion of functions with an
accumulating parameter and its
improvement . . . . . . . . . . . . . . 227--238
Matthias Blume and
Umut A. Acar and
Wonseok Chae Extensible programming with first-class
cases . . . . . . . . . . . . . . . . . 239--250
Dimitrios Vytiniotis and
Stephanie Weirich and
Simon Peyton Jones Boxy types: inference for higher-rank
types and impredicativity . . . . . . . 251--262
Martín Abadi Access control in a core calculus of
dependency . . . . . . . . . . . . . . . 263--273
Chuan-kai Lin Programming monads operationally with
Unimo . . . . . . . . . . . . . . . . . 274--285
Pierre-Malo Deniélou and
James J. Leifer Abstraction preservation and subtyping
in distributed languages . . . . . . . . 286--297
DeLesley Hutchins Eliminating distinctions of class: using
prototypes to model virtual classes . . 1--20
Nathaniel Nystrom and
Xin Qi and
Andrew C. Myers J&: nested intersection for scalable
software composition . . . . . . . . . . 21--36
Alessandro Warth and
Milan Stanojevi\'c and
Todd Millstein Statically scoped object adaptation with
expanders . . . . . . . . . . . . . . . 37--56
Chris Andreae and
James Noble and
Shane Markstrum and
Todd Millstein A framework for implementing pluggable
type systems . . . . . . . . . . . . . . 57--74
George Fairbanks and
David Garlan and
William Scherlis Design fragments make using frameworks
easier . . . . . . . . . . . . . . . . . 75--88
Tal Cohen and
Joseph (Yossi) Gil and
Itay Maman JTL: the Java tools language . . . . . . 89--108
Christoph Bockisch and
Matthew Arnold and
Tom Dinkelaker and
Mira Mezini Adapting virtual machine techniques for
seamless aspect support . . . . . . . . 109--124
Christoph Bockisch and
Sebastian Kanthak and
Michael Haupt and
Matthew Arnold and
Mira Mezini Efficient control flow quantification 125--138
Patrick Eugster Uniform proxies for Java . . . . . . . . 139--152
Jonas Maebe and
Dries Buytaert and
Lieven Eeckhout and
Koen De Bosschere Javana: a system for building customized
Java program analysis tools . . . . . . 153--168
Stephen M. Blackburn and
Robin Garner and
Chris Hoffmann and
Asjad M. Khang and
Kathryn S. McKinley and
Rotem Bentzur and
Amer Diwan and
Daniel Feinberg and
Daniel Frampton and
Samuel Z. Guyer and
Martin Hirzel and
Antony Hosking and
Maria Jump and
Han Lee and
J. Eliot B. Moss and
B. Moss and
Aashish Phansalkar and
Darko Stefanovi\'c and
Thomas VanDrunen and
Daniel von Dincklage and
Ben Wiedermann The DaCapo benchmarks: Java benchmarking
development and analysis . . . . . . . . 169--190
Ben L. Titzer Virgil: objects on the head of a pin . . 191--208
Martin Bravenboer and
Éric Tanter and
Eelco Visser Declarative, formal, and extensible
syntax definition for aspectJ . . . . . 209--228
John Cavazos and
Michael F. P. O'Boyle Method-specific dynamic compilation
using logistic regression . . . . . . . 229--240
Kazunori Ogata and
Tamiya Onodera and
Kiyokuni Kawachiya and
Hideaki Komatsu and
Toshio Nakatani Replay compilation: improving
debuggability of a just-in-time compiler 241--252
Maurice Herlihy and
Victor Luchangco and
Mark Moir A flexible framework for implementing
software transactional memory . . . . . 253--262
Kenneth Russell and
David Detlefs Eliminating synchronization-related
atomic operations with biased locking
and bulk rebiasing . . . . . . . . . . . 263--272
Wei-Ngan Chin and
Florin Craciun and
Siau-Cheng Khoo and
Corneliu Popeea A flow-based approach for variant
parametric types . . . . . . . . . . . . 273--290
Douglas Gregor and
Jaakko Järvi and
Jeremy Siek and
Bjarne Stroustrup and
Gabriel Dos Reis and
Andrew Lumsdaine Concepts: linguistic support for generic
programming in C++ . . . . . . . . . . . 291--310
Alex Potanin and
James Noble and
Dave Clarke and
Robert Biddle Generic ownership for generic Java . . . 311--324
Yu David Liu and
Scott F. Smith A formal framework for component
deployment . . . . . . . . . . . . . . . 325--344
Daniel Wasserrab and
Tobias Nipkow and
Gregor Snelting and
Frank Tip An operational semantics and type safety
proof for multiple inheritance in C++ 345--362
Paul T. Darga and
Chandrasekhar Boyapati Efficient software model checking of
data structure properties . . . . . . . 363--382
Lo Kwun Kit and
Chan Kwun Man and
Elisa Baniassad Isolating and relating concerns in
requirements using latent semantic
analysis . . . . . . . . . . . . . . . . 383--396
Gareth Baxter and
Marcus Frean and
James Noble and
Mark Rickerby and
Hayden Smith and
Matt Visser and
Hayden Melton and
Ewan Tempero Understanding the shape of Java software 397--412
Naiyana Sahavechaphan and
Kajal Claypool XSnippet: mining For sample code . . . . 413--430
Richard P. Gabriel and
Ron Goldman Conscientious software . . . . . . . . . 433--450
Charles Simonyi and
Magnus Christerson and
Shane Clifford Intentional software . . . . . . . . . . 451--464
Jim Waldo On system design . . . . . . . . . . . . 467--480
Friedrich Steimann The paradoxical success of
aspect-oriented programming . . . . . . 481--497