Last update:
Wed Nov 8 13:59:28 MST 2023
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
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
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 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 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 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\ualin 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
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
Mendel Rosenblum Impact of virtualization on computer
architecture and operating systems . . . 1--1
Keith Adams and
Ole Agesen A comparison of software and hardware
techniques for x86 virtualization . . . 2--13
Stephen T. Jones and
Andrea C. Arpaci-Dusseau and
Remzi H. Arpaci-Dusseau Geiger: monitoring the buffer cache in a
virtual machine environment . . . . . . 14--24
Jedidiah R. Crandall and
Gary Wassermann and
Daniela A. S. de Oliveira and
Zhendong Su and
S. Felix Wu and
Frederic T. Chong Temporal search: detecting hidden
malware timebombs with virtual machines 25--36
Shan Lu and
Joseph Tucek and
Feng Qin and
Yuanyuan Zhou AVIO: detecting atomicity violations via
access interleaving invariants . . . . . 37--48
Min Xu and
Mark D. Hill and
Rastislav Bodik A regulated transitive reduction (RTR)
for longer memory race recording . . . . 49--60
Michael D. Bond and
Kathryn S. McKinley Bell: bit-encoding online memory leak
detection . . . . . . . . . . . . . . . 61--72
Smitha Shyam and
Kypros Constantinides and
Sujay Phadke and
Valeria Bertacco and
Todd Austin Ultra low-cost defect protection for
microprocessor pipelines . . . . . . . . 73--82
Vimal K. Reddy and
Eric Rotenberg and
Sailashri Parthasarathy Understanding prediction-based partial
redundant threading for low-overhead,
high- coverage fault tolerance . . . . . 83--94
Angshuman Parashar and
Anand Sivasubramaniam and
Sudhanva Gurumurthi SlicK: slice-based locality exploitation
for efficient redundant multithreading 95--105
Taliver Heath and
Ana Paula Centeno and
Pradeep George and
Luiz Ramos and
Yogesh Jaluria Mercury and Freon: temperature emulation
and management for server systems . . . 106--116
Taeho Kgil and
Shaun D'Souza and
Ali Saidi and
Nathan Binkert and
Ronald Dreslinski and
Trevor Mudge and
Steven Reinhardt and
Krisztian Flautner PicoServer: using $3$D stacking
technology to enable a compact energy
efficient chip multiprocessor . . . . . 117--128
Katherine E. Coons and
Xia Chen and
Doug Burger and
Kathryn S. McKinley and
Sundeep K. Kushwaha A spatial path scheduling algorithm for
EDGE architectures . . . . . . . . . . . 129--140
Martha Mercaldi and
Steven Swanson and
Andrew Petersen and
Andrew Putnam and
Andrew Schwerin and
Mark Oskin and
Susan J. Eggers Instruction scheduling for a tiled
dataflow architecture . . . . . . . . . 141--150
Michael I. Gordon and
William Thies and
Saman Amarasinghe Exploiting coarse-grained task, data,
and pipeline parallelism in stream
programs . . . . . . . . . . . . . . . . 151--162
Mahim Mishra and
Timothy J. Callahan and
Tiberiu Chelcea and
Girish Venkataramani and
Seth C. Goldstein and
Mihai Budiu Tartan: evaluating spatial computation
for whole program execution . . . . . . 163--174
Stijn Eyerman and
Lieven Eeckhout and
Tejas Karkhanis and
James E. Smith A performance counter architecture for
computing accurate CPI components . . . 175--184
Benjamin C. Lee and
David M. Brooks Accurate and efficient regression
modeling for microarchitectural
performance and power prediction . . . . 185--194
Engin Ïpek and
Sally A. McKee and
Rich Caruana and
Bronis R. de Supinski and
Martin Schulz Efficiently exploring architectural
design spaces via predictive modeling 195--206
Mazen Kharbutli and
Xiaowei Jiang and
Yan Solihin and
Guru Venkataramani and
Milos Prvulovic Comprehensively and efficiently
protecting the heap . . . . . . . . . . 207--218
Trishul M. Chilimbi and
Vinod Ganapathy HeapMD: identifying heap-based bugs
using anomaly detection . . . . . . . . 219--228
Satish Narayanasamy and
Cristiano Pereira and
Brad Calder Recording shared memory dependencies
using strata . . . . . . . . . . . . . . 229--240
Jaidev P. Patwardhan and
Vijeta Johri and
Chris Dwyer and
Alvin R. Lebeck A defect tolerant self-organizing
nanoscale SIMD architecture . . . . . . 241--251
Ethan Schuchman and
T. N. Vijaykumar A program transformation and
architecture support for quantum
uncomputation . . . . . . . . . . . . . 252--263
Shashidhar Mysore and
Banit Agrawal and
Navin Srivastava and
Sheng-Chih Lin and
Kaustav Banerjee and
Tim Sherwood Introspective $3$D chips . . . . . . . . 264--273
Jason F. Cantin and
Mikko H. Lipasti and
James E. Smith Stealth prefetching . . . . . . . . . . 274--282
Koushik Chakraborty and
Philip M. Wells and
Gurindar S. Sohi Computation spreading: employing
hardware migration to specialize CMP
cores on-the-fly . . . . . . . . . . . . 283--292
Jason E. Miller and
Anant Agarwal Software-based instruction caching for
embedded processors . . . . . . . . . . 293--302
Xin Li and
Marian Boldt and
Reinhard von Hanxleden Mapping Esterel onto a multi-threaded
embedded processor . . . . . . . . . . . 303--314
Nathan L. Binkert and
Ali G. Saidi and
Steven K. Reinhardt Integrated network interfaces for
high-bandwidth TCP/IP . . . . . . . . . 315--324
David Tarditi and
Sidd Puri and
Jose Oglesby Accelerator: using data parallelism to
program GPUs for general-purpose uses 325--335
Peter Damron and
Alexandra Fedorova and
Yossi Lev and
Victor Luchangco and
Mark Moir and
Daniel Nussbaum Hybrid transactional memory . . . . . . 336--346
Weihaw Chuang and
Satish Narayanasamy and
Ganesh Venkatesh and
Jack Sampson and
Michael Van Biesbrouck and
Gilles Pokam and
Brad Calder and
Osvaldo Colavin Unbounded page-based transactional
memory . . . . . . . . . . . . . . . . . 347--358
Michelle J. Moravan and
Jayaram Bobba and
Kevin E. Moore and
Luke Yen and
Mark D. Hill and
Ben Liblit and
Michael M. Swift and
David A. Wood Supporting nested transactional memory
in logTM . . . . . . . . . . . . . . . . 359--370
JaeWoong Chung and
Chi Cao Minh and
Austen McDonald and
Travis Skare and
Hassan Chafi and
Brian D. Carlstrom and
Christos Kozyrakis and
Kunle Olukotun Tradeoffs in transactional memory
virtualization . . . . . . . . . . . . . 371--381
Motohiro Kawahito and
Hideaki Komatsu and
Takao Moriyama and
Hiroshi Inoue and
Toshio Nakatani A new idiom recognition framework for
exploiting hardware-assist instructions 382--393
Sorav Bansal and
Alex Aiken Automatic generation of peephole
superoptimizers . . . . . . . . . . . . 394--403
Armando Solar-Lezama and
Liviu Tancau and
Rastislav Bodik and
Sanjit Seshia and
Vijay Saraswat Combinatorial sketching for finite
programs . . . . . . . . . . . . . . . . 404--415
Jeff Da Silva and
J. Gregory Steffan A probabilistic pointer analysis for
speculative optimizations . . . . . . . 416--425
Paul Frenger Forth & small systems report: potential
unrealized: the MicroMED advisor . . . . 10--16
Fangjun Wu Formal specification of program slicing 18--27
Sandya Mannarswamy and
Shruti Doval and
Hariharan Sandanagobalane and
Mahesha Nanjundaiah TRICK: tracking and reusing compiler's
knowledge . . . . . . . . . . . . . . . 28--37
B. Wang and
C. Pronk Design and implementation of a GUI for
the TLC model checker . . . . . . . . . 38--43
Alpana Dubey Goodness criteria for programming
language grammar rules . . . . . . . . . 44--53
Audrey Tang Perl 6: reconciling the irreconcilable 1--1
Jacob Matthews and
Robert Bruce Findler Operational semantics for multi-language
programs . . . . . . . . . . . . . . . . 3--10
Pavel Avgustinov and
Elnar Hajiyev and
Neil Ongkingco and
Oege de Moor and
Damien Sereni and
Julian Tibble and
Mathieu Verbaere Semantics of static pointcuts in aspectJ 11--23
Juan Chen A typed intermediate language for
compiling multiple inheritance . . . . . 25--30
Maria Jump and
Kathryn S. McKinley Cork: dynamic memory leak detection for
garbage-collected languages . . . . . . 31--38
Marina Polishchuk and
Ben Liblit and
Chloë W. Schulze Dynamic heap type inference for program
understanding and debugging . . . . . . 39--46
Patrice Godefroid Compositional dynamic test generation 47--54
Xipeng Shen and
Jonathan Shaw and
Brian Meeker and
Chen Ding Locality approximation using time . . . 55--61
Derek Dreyer and
Robert Harper and
Manuel M. T. Chakravarty and
Gabriele Keller Modular type classes . . . . . . . . . . 63--70
Jeffrey Mark Siskind and
Barak A. Pearlmutter First-class nonstandard interpretations
by opening closures . . . . . . . . . . 71--76
Yitzhak Mandelbaum and
Kathleen Fisher and
David Walker and
Mary Fernandez and
Artem Gleyzer PADS/ML: a functional data description
language . . . . . . . . . . . . . . . . 77--83
Andrew M. Pitts and
Mark R. Shinwell Generative unbinding of names . . . . . 85--95
Harvey Tuch and
Gerwin Klein and
Michael Norrish Types, bytes, and separation logic . . . 97--108
Andrew W. Appel and
Paul-André Melli\`es and
Christopher D. Richards and
Jérôme Vouillon A very modal model of a modern, major,
general type system . . . . . . . . . . 109--122
Cristiano Calcagno and
Philippa Gardner and
Uri Zarfaty Context logic as modal logic:
completeness and parametric
inexpressivity . . . . . . . . . . . . . 123--134
Don Batory From implementation to theory in product
synthesis . . . . . . . . . . . . . . . 135--136
Ralf Lämmel Scrap your boilerplate with XPath-like
combinators . . . . . . . . . . . . . . 137--142
Atsushi Ohori and
Isao Sasano Lightweight fusion by fixed point
promotion . . . . . . . . . . . . . . . 143--154
Barak A. Pearlmutter and
Jeffrey Mark Siskind Lazy multivariate higher-order
forward-mode AD . . . . . . . . . . . . 155--160
Kristian Stòvring and
Soren B. Lassen A complete, co-inductive syntactic
theory of sequential control and state 161--172
Daniel K. Lee and
Karl Crary and
Robert Harper Towards a mechanized metatheory of
standard ML . . . . . . . . . . . . . . 173--184
Matthew Might Logic-flow analysis of higher-order
programs . . . . . . . . . . . . . . . . 185--198
Ben Wiedermann and
William R. Cook Extracting queries by static analysis of
transparent persistence . . . . . . . . 199--210
Josh Berdine and
Aziem Chawdhary and
Byron Cook and
Dino Distefano and
Peter O'Hearn Variance analyses from invariance
analyses . . . . . . . . . . . . . . . . 211--224
Pasquale Malacaria Assessing security threats of looping
constructs . . . . . . . . . . . . . . . 225--235
Dachuan Yu and
Ajay Chander and
Nayeem Islam and
Igor Serikov JavaScript instrumentation for browser
security . . . . . . . . . . . . . . . . 237--249
Michele Bugliesi and
Marco Giunti Secure implementations of typed channel
abstractions . . . . . . . . . . . . . . 251--262
Chet Murthy Advanced programming language design in
enterprise software: a lambda-calculus
theorist wanders into a datacenter . . . 263--264
Byron Cook and
Alexey Gotsman and
Andreas Podelski and
Andrey Rybalchenko and
Moshe Y. Vardi Proving that programs eventually do
something good . . . . . . . . . . . . . 265--276
Sumit Gulwani and
Nebojsa Jojic Program verification as probabilistic
inference . . . . . . . . . . . . . . . 277--289
Michael Emmi and
Jeffrey S. Fischer and
Ranjit Jhala and
Rupak Majumdar Lock allocation . . . . . . . . . . . . 291--296
Matthew Parkinson and
Richard Bornat and
Peter O'Hearn Modular verification of a non-blocking
stack . . . . . . . . . . . . . . . . . 297--302
Vineet Kahlon and
Aarti Gupta On the analysis of interacting pushdown
systems . . . . . . . . . . . . . . . . 303--314
John Reppy and
Yingqi Xiao Specialization of CML message-passing
primitives . . . . . . . . . . . . . . . 315--326
Mayur Naik and
Alex Aiken Conditional must not aliasing for static
race detection . . . . . . . . . . . . . 327--338
Ranjit Jhala and
Rupak Majumdar Interprocedural analysis of asynchronous
programs . . . . . . . . . . . . . . . . 339--350
Kapil Vaswani and
Aditya V. Nori and
Trishul M. Chilimbi Preferential path profiling: compactly
numbering interesting paths . . . . . . 351--362
Dan R. Ghica Geometry of synthesis: a structured
approach to VLSI design . . . . . . . . 363--375
Mila Dalla Preda and
Mihai Christodorescu and
Somesh Jha and
Saumya Debray A semantics-based approach to malware
detection . . . . . . . . . . . . . . . 377--388
Hsiang-Yang Chen and
Ting-Wei Hou and
Chun-Liang Lin Tamper-proofing basis path by using
oblivious hashing on Java . . . . . . . 9--16
Rajeev Kumar and
Soham S. Chakraborty Precise static type analysis for object
oriented programs . . . . . . . . . . . 17--26
Éric Tanter On dynamically-scoped crosscutting
mechanisms . . . . . . . . . . . . . . . 27--33
William R. Mahoney and
William L. Sousan Using common off-the-shelf tools to
implement dynamic aspects . . . . . . . 34--41
Paul Frenger Forth & small systems report . . . . . . 2--5
Chin-Yang Lin and
Ting-Wei Hou A simple and efficient algorithm for
cycle collection . . . . . . . . . . . . 7--13
Cristóbal Pareja-Flores and
Jamie Urquiza-Fuentes and
J. Ángel Velázquez-Iturbide WinHIPE: an IDE for functional
programming based on rewriting and
visualization . . . . . . . . . . . . . 14--23
Shujuan Jiang and
Yuanpeng Jiang An analysis approach for testing
exception handling programs . . . . . . 3--8
Ting-Wei Hou and
Fuh-Gwo Chen An anomaly in an interpreter using GCC
source-code-level register allocation 9--13
Minkyoung Oh and
Jiyeon Lee and
Byeong-Mo Chang and
Joonseon Ahn and
Kyung-Goo Doh A programming environment for ubiquitous
computing environment . . . . . . . . . 14--22
Igor B. Smirnov Raw pointers in application classes of
C++ considered harmful . . . . . . . . . 23--31
Huihui Shi and
Yi Wang and
Haibing Guan and
Alei Liang An intermediate language level
optimization framework for dynamic
binary translation . . . . . . . . . . . 3--9
Jayasri Banerjee and
Anup Kumar Bandyopadhyay and
Ajit Kumar Mandal Some investigations on deadlock freedom
issues of a cyclically connected system
using Dijkstra's weakest precondition
calculus . . . . . . . . . . . . . . . . 10--15
Gene Novark and
Emery D. Berger and
Benjamin G. Zorn Exterminator: automatically correcting
memory errors with high probability . . 1--11
Sebastian Burckhardt and
Rajeev Alur and
Milo M. K. Martin CheckFence: checking consistency of
concurrent data types on relaxed memory
models . . . . . . . . . . . . . . . . . 12--21
Satish Narayanasamy and
Zhenghao Wang and
Jordan Tigani and
Andrew Edwards and
Brad Calder Automatically classifying benign and
harmful data races all using replay
analysis . . . . . . . . . . . . . . . . 22--31
Gary Wassermann and
Zhendong Su Sound and precise analysis of Web
applications for injection
vulnerabilities . . . . . . . . . . . . 32--41
Frances Perry and
Lester Mackey and
George A. Reis and
Jay Ligatti and
David I. August and
David Walker Fault-tolerant typed assembly language 42--53
Adam Chlipala A certified type-preserving compiler
from lambda calculus to assembly
language . . . . . . . . . . . . . . . . 54--65
Hongxu Cai and
Zhong Shao and
Alexander Vaynberg Certified self-modifying code . . . . . 66--77
Tatiana Shpeisman and
Vijay Menon and
Ali-Reza Adl-Tabatabai and
Steven Balensiefer and
Dan Grossman and
Richard L. Hudson and
Katherine F. Moore and
Bratin Saha Enforcing isolation and ordering in STM 78--88
Nicholas Nethercote and
Julian Seward Valgrind: a framework for heavyweight
dynamic binary instrumentation . . . . . 89--100
Jungwoo Ha and
Christopher J. Rossbach and
Jason V. Davis and
Indrajit Roy and
Hany E. Ramadan and
Donald E. Porter and
David L. Chen and
Emmett Witchel Improved error reporting for software
that uses black-box components . . . . . 101--111
Manu Sridharan and
Stephen J. Fink and
Rastislav Bodik Thin slicing . . . . . . . . . . . . . . 112--122
Murali Krishna Ramanathan and
Ananth Grama and
Suresh Jagannathan Static specification inference using
predicate mining . . . . . . . . . . . . 123--134
Erika Rice Scherpelz and
Sorin Lerner and
Craig Chambers Automatic inference of optimizer flow
functions from semantic meanings . . . . 135--145
Kazutaka Morita and
Akimasa Morihata and
Kiminori Matsuzaki and
Zhenjiang Hu and
Masato Takeichi Automatic inversion generates
divide-and-conquer parallel programs . . 146--155
Perry H. Wang and
Jamison D. Collins and
Gautham N. Chinya and
Hong Jiang and
Xinmin Tian and
Milind Girkar and
Nick Y. Yang and
Guei-Yuan Lueh and
Hong Wang EXOCHI: architecture and programming
environment for a heterogeneous
multi-core multithreaded system . . . . 156--166
Armando Solar-Lezama and
Gilad Arnold and
Liviu Tancau and
Rastislav Bodik and
Vijay Saraswat and
Sanjit Seshia Sketching stencils . . . . . . . . . . . 167--178
Charles Edwin Killian and
James W. Anderson and
Ryan Braud and
Ranjit Jhala and
Amin M. Vahdat Mace: language support for building
distributed systems . . . . . . . . . . 179--188
Peng Li and
Steve Zdancewic Combining events and threads for
scalable network services implementation
and evaluation of monadic,
application-level concurrency primitives 189--199
Nupur Kothari and
Ramakrishna Gummadi and
Todd Millstein and
Ramesh Govindan Reliable and efficient programming
abstractions for wireless sensor
networks . . . . . . . . . . . . . . . . 200--210
Milind Kulkarni and
Keshav Pingali and
Bruce Walter and
Ganesh Ramanarayanan and
Kavita Bala and
L. Paul Chew Optimistic parallelism requires
abstractions . . . . . . . . . . . . . . 211--222
Chen Ding and
Xipeng Shen and
Kirk Kelsey and
Chris Tice and
Ruke Huang and
Chengliang Zhang Software behavior oriented
parallelization . . . . . . . . . . . . 223--234
Sriram Krishnamoorthy and
Muthu Baskaran and
Uday Bondhugula and
J. Ramanujam and
Atanas Rountev and
P. Sadayappan Effective automatic parallelization of
stencil computations . . . . . . . . . . 235--244
Tayfun Elmas and
Shaz Qadeer and
Serdar Tasiran Goldilocks: a race and transaction-aware
Java runtime . . . . . . . . . . . . . . 245--255
Bolei Guo and
Neil Vachharajani and
David I. August Shape analysis with inductive recursion
synthesis . . . . . . . . . . . . . . . 256--265
Alexey Gotsman and
Josh Berdine and
Byron Cook and
Mooly Sagiv Thread-modular shape analysis . . . . . 266--277
Chris Lattner and
Andrew Lenharth and
Vikram Adve Making context-sensitive points-to
analysis with heap cloning practical for
the real world . . . . . . . . . . . . . 278--289
Ben Hardekopf and
Calvin Lin The ant and the grasshopper: fast and
accurate pointer analysis for millions
of lines of code . . . . . . . . . . . . 290--299
Dirk Beyer and
Thomas A. Henzinger and
Rupak Majumdar and
Andrey Rybalchenko Path invariants . . . . . . . . . . . . 300--309
Ajeet Shankar and
Rastislav Bodík DITTO: automatic incrementalization of
data structure invariant checks (in
Java) . . . . . . . . . . . . . . . . . 310--319
Byron Cook and
Andreas Podelski and
Andrey Rybalchenko Proving thread termination . . . . . . . 320--330
John Kodumal and
Alex Aiken Regularly annotated set constraints . . 331--341
Pierre Genev\`es and
Nabil Laya\"\ida and
Alan Schmitt Efficient static analysis of XML paths
and types . . . . . . . . . . . . . . . 342--351
Ben L. Titzer and
Joshua Auerbach and
David F. Bacon and
Jens Palsberg The ExoVM system for automatic VM and
application reduction . . . . . . . . . 352--362
Nathan Dean Cooprider and
John David Regehr Offline compression for on-chip RAM . . 363--372
Florian T. Schneider and
Mathias Payer and
Thomas R. Gross Online optimizations driven by hardware
performance monitoring . . . . . . . . . 373--382
Weijia Li and
Youtao Zhang and
Jun Yang and
Jiang Zheng UCC: update-conscious compilation for
energy efficiency in wireless sensor
networks . . . . . . . . . . . . . . . . 383--393
Feihui Li and
Guangyu Chen and
Mahmut Kandemir and
Ibrahim Kolcu Profile-driven energy reduction in
network-on-chips . . . . . . . . . . . . 394--404
Lakshminarayanan Renganarayanan and
DaeGon Kim and
Sanjay Rajopadhye and
Michelle Mills Strout Parameterized tiled loops for free . . . 405--414
Xiangyu Zhang and
Sriraman Tallam and
Neelam Gupta and
Rajiv Gupta Towards locating execution omission
errors . . . . . . . . . . . . . . . . . 415--424
Benjamin S. Lerner and
Matthew Flower and
Dan Grossman and
Craig Chambers Searching for type-error messages . . . 425--434
Isil Dillig and
Thomas Dillig and
Alex Aiken Static error detection using semantic
inconsistency inference . . . . . . . . 435--445
Madanlal Musuvathi and
Shaz Qadeer Iterative context bounding for
systematic testing of multithreaded
programs . . . . . . . . . . . . . . . . 446--455
Martin T. Vechev and
Eran Yahav and
David F. Bacon and
Noam Rinetzky CGCExplorer: a semi-automated search
procedure for provably correct
concurrent collectors . . . . . . . . . 456--467
Andrew McCreight and
Zhong Shao and
Chunxiao Lin and
Long Li A general framework for certifying
garbage collectors and their mutators 468--479
Sigmund Cherem and
Lonnie Princehouse and
Radu Rugina Practical memory leak detection using
guarded value-flow analysis . . . . . . 480--491
Pratibha Permandla and
Michael Roberson and
Chandrasekhar Boyapati A type system for preventing data races
and deadlocks in the Java Virtual
Machine language: 1 . . . . . . . . . . 10--10
Tai-Yi Huang and
Pin-Chuan Chou and
Cheng-Han Tsai and
Hsin-An Chen Automated fault localization with
statistically suspicious program states 11--20
Xiliang Zhong and
Cheng-Zhong Xu Frequency-aware energy optimization for
real-time periodic and aperiodic tasks 21--30
Yifan Zhu and
Frank Mueller DVSleak: combining leakage reduction and
voltage scaling in feedback EDF
scheduling . . . . . . . . . . . . . . . 31--40
Nevine AbouGhazaleh and
Alexandre Ferreira and
Cosmin Rusu and
Ruibin Xu and
Frank Liberato and
Bruce Childers and
Daniel Mosse and
Rami Melhem Integrated CPU and l2 cache voltage
scaling using machine learning . . . . . 41--50
Joshua Auerbach and
David F. Bacon and
Daniel T. Iercan and
Christoph M. Kirsch and
V. T. Rajan and
Harald Roeck and
Rainer Trummer Java takes flight: time-portable
real-time programming with exotasks . . 51--62
SungHyun Hong and
Jin-Chul Kim and
Jin Woo Shin and
Soo-Mook Moon and
Hyeong-Seok Oh and
Jaemok Lee and
Hyung-Kyu Choi Java client ahead-of-time compiler for
embedded systems . . . . . . . . . . . . 63--72
Christophe Alias and
Fabrice Baray and
Alain Darte Bee+Cl@k: an implementation of
lattice-based array contraction in the
source-to-source translator rose . . . . 73--82
Richard Vincent Bennett and
Alastair Colin Murray and
Björn Franke and
Nigel Topham Combining source-to-source
transformations and processor
instruction set extensions for the
automated design-space exploration of
embedded systems . . . . . . . . . . . . 83--92
Minwook Ahn and
Jooyeon Lee and
Yunheung Paek Optimistic coalescing for heterogeneous
register architectures . . . . . . . . . 93--102
Florent Bouchez and
Alain Darte and
Fabrice Rastello On the complexity of spill everywhere
under SSA form . . . . . . . . . . . . . 103--112
Weifeng Xu and
Russell Tessier Tetris: a new register pressure control
technique for VLIW processors . . . . . 113--122
Filip Pizlo and
Antony L. Hosking and
Jan Vitek Hierarchical real-time garbage
collection . . . . . . . . . . . . . . . 123--133
Kathryn O'Brien Issues and challenges in compiling for
the CBEA . . . . . . . . . . . . . . . . 134--134
Daniel Kaestner Safe worst-case execution time analysis
by abstract interpretation of executable
code . . . . . . . . . . . . . . . . . . 135--135
Jonathan Engelsma Enabling seamless mobility: an enablers,
experiences and tools perspective . . . 136--136
Po-Kuan Huang and
Matin Hashemi and
Soheil Ghiasi Joint throughput and energy optimization
for pipelined execution of embedded
streaming applications . . . . . . . . . 137--139
Hansu Cho and
Samar Abdi and
Daniel Gajski Interface synthesis for heterogeneous
multi-core systems from transaction
level models . . . . . . . . . . . . . . 140--142
Ines Viskic and
Samar Abdi and
Daniel D. Gajski Automatic generation of embedded
communication SW for heterogeneous MPSoC
platforms . . . . . . . . . . . . . . . 143--145
Chung-Kai Chen and
Ling-Hua Tseng and
Shih-Chang Chen and
Young-Jia Lin and
Yi-Ping You and
Chia-Han Lu and
Jenq-Kuen Lee Enabling compiler flow for embedded VLIW
DSP processors with distributed register
files . . . . . . . . . . . . . . . . . 146--148
Karsten Walther and
René Herzog and
Jörg Nolte Analyzing the real-time behaviour of
deeply embedded event driven systems . . 149--151
Joel Coffman and
Christopher Healy and
Frank Mueller and
David Whalley Generalizing parametric timing analysis 152--154
Guangyu Chen and
Feihui Li and
Mahmut Kandemir Compiler-directed application mapping
for NoC based chip multiprocessors . . . 155--157
Shan Yan and
Bill Lin Stream execution on wide-issue clustered
VLIW architectures . . . . . . . . . . . 158--160
Michael L. Chu and
Scott A. Mahlke Code and data partitioning for
fine-grain parallelism . . . . . . . . . 161--164
Stephen Roderick Hines and
Gary Tyson and
David Whalley Addressing instruction fetch bottlenecks
by using an instruction register file 165--174
Jun Yan and
Wei Zhang WCET analysis of instruction caches with
prefetching . . . . . . . . . . . . . . 175--184
Ke Ning and
David Kaeli External memory page remapping for
embedded multimedia systems . . . . . . 185--194
Hyungmin Cho and
Bernhard Egger and
Jaejin Lee and
Heonshik Shin Dynamic data scratchpad memory
management for a memory subsystem with
an MMU . . . . . . . . . . . . . . . . . 195--206
Lian Li and
Quan Hoang Nguyen and
Jingling Xue Scratchpad allocation for data
aggregates in superperfect graphs . . . 207--216
Jihyun In and
Ilhoon Shin and
Hyojun Kim SWL: a search-while-load demand paging
scheme with NAND flash memory . . . . . 217--226
Qin Wang and
Junpu Chen and
Weihua Zhang and
Min Yang and
Binyu Zang Optimizing software cache performance of
packet processing applications . . . . . 227--236
Rajiv Ravindran and
Michael Chu and
Scott Mahlke Compiler-managed partitioned data caches
for low power . . . . . . . . . . . . . 237--247
Michael Dunlavey Performance tuning with
instruction-level cost derived from
call-stack sampling . . . . . . . . . . 4--8
Yarom Gabay and
Assaf J. Kfoury A calculus for Java's reference objects 9--17
Peter Sewell and
Francesco Zappa Nardelli and
Scott Owens and
Gilles Peskine and
Thomas Ridge and
Susmit Sarkar and
Rok Strni\vsa Ott: effective tool support for the
working semanticist . . . . . . . . . . 1--12
Matthieu Sozeau Programming finger trees in Coq . . . . 13--24
Jeremy Wazny Experience report: functional
programming in c-rules . . . . . . . . . 25--28
Don Syme and
Gregory Neverov and
James Margetson Extensible pattern matching via a
lightweight language extension . . . . . 29--40
Olivier Danvy and
Michael Spivey On Barron and Strachey's Cartesian
product function . . . . . . . . . . . . 41--46
Kazutaka Matsuda and
Zhenjiang Hu and
Keisuke Nakano and
Makoto Hamana and
Masato Takeichi Bidirectionalization transformation
based on automatic derivation of view
complement functions . . . . . . . . . . 47--58
Conal M. Elliott Tangible functional programming . . . . 59--70
Damien Sereni Termination analysis and call graph
construction for higher-order functional
programs . . . . . . . . . . . . . . . . 71--84
David Van Horn and
Harry G. Mairson Relating complexity and precision in
control flow analysis . . . . . . . . . 85--96
Andrzej Filinski and
Kristian Stòvring Inductive reasoning about effectful data
types . . . . . . . . . . . . . . . . . 97--110
Daan Leijen A type directed translation of MLF to
system F . . . . . . . . . . . . . . . . 111--122
John W. Lloyd Declarative programming for artificial
intelligence applications . . . . . . . 123--124
Lars-Åke Fredlund and
Hans Svensson McErlang: a model checker for a
distributed functional programming
language . . . . . . . . . . . . . . . . 125--136
Steve Sims and
Daniel C. DuVarney Experience report: the reactis
validation tool . . . . . . . . . . . . 137--140
Rinus Plasmeijer and
Peter Achten and
Pieter Koopman iTasks: executable specifications of
interactive work flow systems for the
web . . . . . . . . . . . . . . . . . . 141--152
Noel Welsh and
David Gurnell Experience report: scheme in commercial
Web application development . . . . . . 153--156
David Herman Functional pearl: the great escape or,
how to jump the border without getting
caught . . . . . . . . . . . . . . . . . 157--164
Matthew Flatt and
Gang Yu and
Robert Bruce Findler and
Matthias Felleisen Adding delimited and composable control
to a production programming environment 165--176
Andrew Kennedy Compiling with continuations, continued 177--190
Sungwoo Park Type-safe higher-order channels in
ML-like languages . . . . . . . . . . . 191--202
Jan Nyström and
Phil Trinder and
David King Evaluating high-level distributed
language constructs . . . . . . . . . . 203--212
Clifford Beshers and
David Fox and
Jeremy Shaw Experience report: using functional
programming to manage a Linux
distribution . . . . . . . . . . . . . . 213--218
Frank Pfenning Subtyping and intersection types
revisited . . . . . . . . . . . . . . . 219--219
Leif Frenzel Experience report: building an
eclipse-based IDE for Haskell . . . . . 220--222
Rob Ennals and
David Gay User-friendly functional programming for
Web mashups . . . . . . . . . . . . . . 223--234
Jurriaan Hage and
Stefan Holdermans and
Arie Middelkoop A generic usage analysis with subeffect
qualifiers . . . . . . . . . . . . . . . 235--246
Jonathan Cooper and
Steve McKeever Experience report: a Haskell interpreter
for cellML . . . . . . . . . . . . . . . 247--250
Tim Harris and
Satnam Singh Feedback directed implicit parallelism 251--264
Bernd Braßel and
Michael Hanus and
Sebastian Fischer and
Frank Huch and
Germán Vidal Lazy call-by-value evaluation . . . . . 265--276
Simon Marlow and
Alexey Rodriguez Yakushev and
Simon Peyton Jones Faster laziness using dynamic pointer
tagging . . . . . . . . . . . . . . . . 277--288
Derek Dreyer A type system for recursive modules . . 289--302
Abdulaziz Ghuloum and
R. Kent Dybvig Implicit phasing for R6RS libraries . . 303--314
Duncan Coutts and
Roman Leshchinskiy and
Don Stewart Stream fusion: from lists to streams to
nothing at all . . . . . . . . . . . . . 315--326
Simon Peyton Jones Call-pattern specialisation for Haskell
programs . . . . . . . . . . . . . . . . 327--337
Torbjörn Ekman and
Görel Hedin The JastAdd Extensible Java compiler . . 1--18
Martin Hirzel and
Robert Grimm Jeannie: granting Java Native Interface
developers their wishes . . . . . . . . 19--38
Gang Tan and
Greg Morrisett Ilea: inter-language analysis across
Java and C . . . . . . . . . . . . . . . 39--56
Andy Georges and
Dries Buytaert and
Lieven Eeckhout Statistically rigorous Java performance
evaluation . . . . . . . . . . . . . . . 57--76
Feng Xian and
Witawas Srisa-an and
Hong Jiang Microphase: an approach to proactively
invoking garbage collection for improved
performance . . . . . . . . . . . . . . 77--96
Michael D. Bond and
Kathryn S. McKinley Probabilistic calling context . . . . . 97--112
Atsushi Igarashi and
Mirko Viroli Variant path types for scalable
extensibility . . . . . . . . . . . . . 113--132
Vaidas Gasiunas and
Mira Mezini and
Klaus Ostermann Dependent classes . . . . . . . . . . . 133--152
James Sasitorn and
Robert Cartwright Component NEXTGEN: a sound and
expressive component framework for Java 153--170
Stéphane Ducasse and
Roel Wuyts and
Alexandre Bergel and
Oscar Nierstrasz User-changeable visibility: resolving
unanticipated name clashes in traits . . 171--190
Yannis Smaragdakis and
Anthony Kay and
Reimer Behrends and
Michal Young Transactions with isolation and
cooperation . . . . . . . . . . . . . . 191--210
Jesper H. Spring and
Jean Privat and
Rachid Guerraoui and
Jan Vitek StreamFlex: high-throughput stream
programming in Java . . . . . . . . . . 211--228
Thomas Kuehne and
Daniel Schreiber Can programming be liberated from the
two-level style: multi-level programming
with DeepJava . . . . . . . . . . . . . 229--244
Nick Mitchell and
Gary Sevitsky The causes of bloat, the limits of
health . . . . . . . . . . . . . . . . . 245--260
Uri Dekel and
James D. Herbsleb Notation and representation in
collaborative object-oriented design: an
observational study . . . . . . . . . . 261--280
Avraham Leff and
James T. Rayfield WebRB: evaluating a visual
domain-specific language for building
relational web-applications . . . . . . 281--300
Kevin Bierhoff and
Jonathan Aldrich Modular typestate checking of aliased
objects . . . . . . . . . . . . . . . . 301--320
David Greenfieldboyce and
Jeffrey S. Foster Type qualifier inference for Java . . . 321--336
Manuel Fahndrich and
Songtao Xia Establishing object invariants with
delayed types . . . . . . . . . . . . . 337--350
Steve M. Shaner and
Gary T. Leavens and
David A. Naumann Modular verification of higher-order
methods with mandatory calls specified
by model programs . . . . . . . . . . . 351--368
Martin C. Rinard Using early phase termination to
eliminate load imbalances at barrier
synchronization points . . . . . . . . . 369--386
Bassem Elkarablieh and
Sarfraz Khurshid and
Duy Vu and
Kathryn S. McKinley STARC: static analysis for efficient
repair of complex data . . . . . . . . . 387--404
Michael D. Bond and
Nicholas Nethercote and
Stephen W. Kent and
Samuel Z. Guyer and
Kathryn S. McKinley Tracking bad apples: reporting the
origin of null and undefined value
errors . . . . . . . . . . . . . . . . . 405--422
Kin-Keung Ma and
Jeffrey S. Foster Inferring aliasing and encapsulation
properties for Java . . . . . . . . . . 423--440
Nicholas R. Cameron and
Sophia Drossopoulou and
James Noble and
Matthew J. Smith Multiple ownership . . . . . . . . . . . 441--460
Peter Müller and
Arsenii Rudich Ownership transfer in universe types . . 461--478
Gavin M. Bierman and
Erik Meijer and
Mads Torgersen Lost in translation: formalizing
proposed extensions to C# . . . . . . . 479--498
Rok Strni\vsa and
Peter Sewell and
Matthew Parkinson The Java module system: core design and
semantic definition . . . . . . . . . . 499--514
Sergei Kojarski and
David H. Lorenz Awesome: an aspect co-weaving system for
composing multiple aspect-oriented
extensions . . . . . . . . . . . . . . . 515--534
Guillaume Pothier and
Éric Tanter and
José Piquer Scalable omniscient debugging . . . . . 535--552
Dries Buytaert and
Andy Georges and
Michael Hind and
Matthew Arnold and
Lieven Eeckhout and
Koen De Bosschere Using HPM-sampling to drive dynamic
compilation . . . . . . . . . . . . . . 553--568
Feng Chen and
Grigore Ro\csu MOP: an efficient and generic runtime
verification framework . . . . . . . . . 569--588
Pavel Avgustinov and
Julian Tibble and
Oege de Moor Making trace monitors feasible . . . . . 589--608
Martin C. Rinard Living in the comfort zone . . . . . . . 611--622
Sean McDirmid Living it up with a live programming
language . . . . . . . . . . . . . . . . 623--638
Jonathan Edwards No ifs, ands, or buts: uncovering the
simplicity of conditionals . . . . . . . 639--658
Sebastian Fleissner and
Elisa L. A. Baniassad Epi-aspects: aspect-oriented
conscientious software . . . . . . . . . 659--674
Erik Meijer Confessions of a used programming
language salesman . . . . . . . . . . . 677--694
Dan Grossman The transactional memory /garbage
collection analogy . . . . . . . . . . . 695--706
Paul Frenger Hacking your mouse: errata for Mar. 2007 3--3
M. Sarma and
R. Mall Synthesis of system state models . . . . 5--14
Kurt Svensson Faster XML data validation in a
programming language with XML datatypes 15--21
Feng Xia and
Guosong Tian and
Youxian Sun Feedback scheduling: an event-driven
paradigm . . . . . . . . . . . . . . . . 7--14
Apostolos Syropoulos $\Pi$ machines: virtual machines
realizing graph structured transition P
systems . . . . . . . . . . . . . . . . 15--22
Walter Fontana Systems biology, models, and concurrency 1--2
Brian Aydemir and
Arthur Charguéraud and
Benjamin C. Pierce and
Randy Pollack and
Stephanie Weirich Engineering formal metatheory . . . . . 3--15
Jean-Baptiste Tristan and
Xavier Leroy Formal verification of translation
validators: a case study on instruction
scheduling optimizations . . . . . . . . 17--27
Janis Voigtländer Much ado about two (pearl): a pearl on
parallel prefix computation . . . . . . 29--35
Iulian Neamtiu and
Michael Hicks and
Jeffrey S. Foster and
Polyvios Pratikakis Contextual effects for
version-consistent dynamic software
updating all and safe concurrent
programming . . . . . . . . . . . . . . 37--49
Katherine F. Moore and
Dan Grossman High-level small-step operational
semantics for transactions . . . . . . . 51--62
Martín Abadi and
Andrew Birrell and
Tim Harris and
Michael Isard Semantics of transactional memory and
automatic mutual exclusion . . . . . . . 63--74
Matthew J. Parkinson and
Gavin M. Bierman Separation logic, abstraction and
inheritance . . . . . . . . . . . . . . 75--86
Wei-Ngan Chin and
Cristina David and
Huu Hai Nguyen and
Shengchao Qin Enhancing modular OO verification with
separation logic . . . . . . . . . . . . 87--99
James Brotherston and
Richard Bornat and
Cristiano Calcagno Cyclic proofs of program termination in
separation logic . . . . . . . . . . . . 101--112
Andrea Asperti The intensional content of Rice's
theorem . . . . . . . . . . . . . . . . 113--119
Marco Gaboardi and
Jean-Yves Marion and
Simona Ronchi Della Rocca A logical account of pspace . . . . . . 121--131
Nils Anders Danielsson Lightweight semiformal time complexity
analysis for purely functional data
structures . . . . . . . . . . . . . . . 133--144
K. L. McMillan Relevance heuristics for program
analysis . . . . . . . . . . . . . . . . 145--146
Ashutosh Gupta and
Thomas A. Henzinger and
Rupak Majumdar and
Andrey Rybalchenko and
Ru-Gang Xu Proving non-termination . . . . . . . . 147--158
Swarat Chaudhuri Subcubic algorithms for recursive state
machines . . . . . . . . . . . . . . . . 159--169
Shuvendu Lahiri and
Shaz Qadeer Back to the future: revisiting precise
program verification using SMT solvers 171--182
Christopher Unkel and
Monica S. Lam Automatic inference of stationary
fields: a generalization of Java's final
fields . . . . . . . . . . . . . . . . . 183--195
Xin Zheng and
Radu Rugina Demand-driven alias analysis for C . . . 197--208
Marius Nita and
Dan Grossman and
Craig Chambers A theory of platform-dependent low-level
software . . . . . . . . . . . . . . . . 209--220
Greta Yorsh and
Eran Yahav and
Satish Chandra Generating precise and concise procedure
summaries . . . . . . . . . . . . . . . 221--234
Sumit Gulwani and
Bill McCloskey and
Ashish Tiwari Lifting abstract interpreters to
quantified logical domains . . . . . . . 235--246
Bor-Yuh Evan Chang and
Xavier Rival Relational inductive shape analysis . . 247--260
Giuseppe Castagna and
Nils Gesbert and
Luca Padovani A theory of contracts for Web services 261--272
Kohei Honda and
Nobuko Yoshida and
Marco Carbone Multiparty asynchronous session types 273--284
Yaron M. Minsky Caml trading . . . . . . . . . . . . . . 285--285
Conor McBride Clowns to the left of me, jokers to the
right (pearl): dissecting data
structures . . . . . . . . . . . . . . . 287--295
Patricia Johann and
Neil Ghani Foundations for structured programming
with GADTs . . . . . . . . . . . . . . . 297--308
Umut A. Acar and
Amal Ahmed and
Matthias Blume Imperative self-adjusting computation 309--322
Cédric Fournet and
Tamara Rezk Cryptographically sound implementations
for typed information-flow security . . 323--335
Peeter Laud On the computational soundness of
cryptographically masked flows . . . . . 337--348
Hamed Seiied Alavi and
Seth Gilbert and
Rachid Guerraoui Extensible encoding of type hierarchies 349--358
Noam Zeilberger Focusing and higher-order abstract
syntax . . . . . . . . . . . . . . . . . 359--369
Brigitte Pientka A type-theoretic foundation for
programming with higher-order abstract
syntax and first-class substitutions . . 371--382
Hugo Herbelin and
Silvia Ghilezan An approach to call-by-name delimited
continuations . . . . . . . . . . . . . 383--394
Sam Tobin-Hochstadt and
Matthias Felleisen The design and implementation of typed
scheme . . . . . . . . . . . . . . . . . 395--406
Aaron Bohannon and
J. Nathan Foster and
Benjamin C. Pierce and
Alexandre Pilkiewicz and
Alan Schmitt Boomerang: resourceful lenses for string
data . . . . . . . . . . . . . . . . . . 407--419
Kathleen Fisher and
David Walker and
Kenny Q. Zhu and
Peter White From dirt to shovels: fully automatic
tool generation from ad hoc data . . . . 421--434
John Fitzgerald and
Peter Gorm Larsen and
Shin Sahara VDMTools: advances in support for formal
modeling in VDM . . . . . . . . . . . . 3--11
Jia Lu and
Jing Ying and
Ming hu Wu and
Cang Hong Jin Crosscutting invariant and an efficient
checking algorithm using program slicing 12--20
Ju Qian and
Baowen Xu Program slicing under UML scenario
models . . . . . . . . . . . . . . . . . 21--24
Danfeng Zhang and
Yao Guo and
Xiangqun Chen AspectC2C: a symmetric aspect extension
to the C language . . . . . . . . . . . 25--32
Erik Winfree Toward molecular programming with DNA 1--1
Xiaoxin Chen and
Tal Garfinkel and
E. Christopher Lewis and
Pratap Subrahmanyam and
Carl A. Waldspurger and
Dan Boneh and
Jeffrey Dwoskin and
Dan R. K. Ports Overshadow: a virtualization-based
approach to retrofitting protection in
commodity operating systems . . . . . . 2--13
Jonathan M. McCune and
Bryan Parno and
Adrian Perrig and
Michael K. Reiter and
Arvind Seshadri How low can you go?: recommendations for
hardware-supported minimal TCB code
execution . . . . . . . . . . . . . . . 14--25
Ravi Bhargava and
Benjamin Serebrin and
Francesco Spadini and
Srilatha Manne Accelerating two-dimensional page walks
for virtualized systems . . . . . . . . 26--35
Benjamin C. Lee and
David Brooks Efficiency trends and limits from
comprehensive microarchitectural
adaptivity . . . . . . . . . . . . . . . 36--47
Ramya Raghavendra and
Parthasarathy Ranganathan and
Vanish Talwar and
Zhikui Wang and
Xiaoyun Zhu No 'power' struggles: coordinated
multi-level power management for the
data center . . . . . . . . . . . . . . 48--59
Chinnakrishnan S. Ballapuram and
Ahmad Sharif and
Hsien-Hsin S. Lee Exploiting access semantics and program
behavior to reduce snoop power in chip
multiprocessors . . . . . . . . . . . . 60--69
Arindam Mallik and
Jack Cosgrove and
Robert P. Dick and
Gokhan Memik and
Peter Dinda PICSEL: measuring user-perceived
performance to control dynamic frequency
scaling . . . . . . . . . . . . . . . . 70--79
Jose A. Joao and
Onur Mutlu and
Hyesoon Kim and
Rishi Agarwal and
Yale N. Patt Improving the performance of
object-oriented languages with dynamic
predication of indirect jumps . . . . . 80--90
Michal Wegiel and
Chandra Krintz The mapping collector: virtual memory
support for generational, parallel, and
concurrent compaction . . . . . . . . . 91--102
Joe Devietti and
Colin Blundell and
Milo M. K. Martin and
Steve Zdancewic Hardbound: architectural support for
spatial safety of the C programming
language . . . . . . . . . . . . . . . . 103--114
Vitaliy B. Lvin and
Gene Novark and
Emery D. Berger and
Benjamin G. Zorn Archipelago: trading address space for
reliability and security . . . . . . . . 115--124
Bumyong Choi and
Leo Porter and
Dean M. Tullsen Accurate branch prediction for short
threads . . . . . . . . . . . . . . . . 125--134
Shekhar Srikantaiah and
Mahmut Kandemir and
Mary Jane Irwin Adaptive set pinning: managing shared
caches in chip multiprocessors . . . . . 135--144
James Tuck and
Wonsun Ahn and
Luis Ceze and
Josep Torrellas SoftSig: software-exposed hardware
signatures for code analysis and
optimization . . . . . . . . . . . . . . 145--156
Ioana Burcea and
Stephen Somogyi and
Andreas Moshovos and
Babak Falsafi Predictor virtualization . . . . . . . . 157--167
Vinod Ganapathy and
Matthew J. Renzelmann and
Arini Balakrishnan and
Michael M. Swift and
Somesh Jha The design and implementation of
microdrivers . . . . . . . . . . . . . . 168--178
Yaron Weinsberg and
Danny Dolev and
Tal Anker and
Muli Ben-Yehuda and
Pete Wyckoff Tapping into the fountain of CPUs: on
operating system support for
programmable devices . . . . . . . . . . 179--188
Kai Shen and
Ming Zhong and
Sandhya Dwarkadas and
Chuanpeng Li and
Christopher Stewart and
Xiao Zhang Hardware counter driven on-the-fly
request signatures . . . . . . . . . . . 189--200
Luk Van Ertvelde and
Lieven Eeckhout Dispersing proprietary applications as
benchmarks through code mutation . . . . 201--210
Shashidhar Mysore and
Bita Mazloom and
Banit Agrawal and
Timothy Sherwood Understanding and visualizing full
systems with data flow tomography . . . 211--221
Guilherme Ottoni and
David I. August Communication optimizations for global
multi-threaded instruction scheduling 222--232
Milind Kulkarni and
Keshav Pingali and
Ganesh Ramanarayanan and
Bruce Walter and
Kavita Bala and
L. Paul Chew Optimistic parallelism benefits from
data partitioning . . . . . . . . . . . 233--243
Russ Cox and
Tom Bergan and
Austin T. Clements and
Frans Kaashoek and
Eddie Kohler Xoc, an extension-oriented compiler for
systems programming . . . . . . . . . . 244--254
Philip M. Wells and
Koushik Chakraborty and
Gurindar S. Sohi Adapting to intermittent faults in
multicore systems . . . . . . . . . . . 255--264
Man-Lap Li and
Pradeep Ramachandran and
Swarup Kumar Sahoo and
Sarita V. Adve and
Vikram S. Adve and
Yuanyuan Zhou Understanding the propagation of hard
errors to software and implications for
resilient system design . . . . . . . . 265--276
M. Aater Suleman and
Moinuddin K. Qureshi and
Yale N. Patt Feedback-driven threading:
power-efficient and high-performance
execution of multi-threaded workloads on
CMPs . . . . . . . . . . . . . . . . . . 277--286
Michael D. Linderman and
Jamison D. Collins and
Hong Wang and
Teresa H. Meng Merge: a programming model for
heterogeneous multi-core systems . . . . 287--296
Jayanth Gummaraju and
Joel Coburn and
Yoshio Turner and
Mendel Rosenblum Streamware: programming general-purpose
multicore processors using streams . . . 297--307
Edmund B. Nightingale and
Daniel Peek and
Peter M. Chen and
Jason Flinn Parallelizing security checks on
commodity hardware . . . . . . . . . . . 308--318
Miguel Castro and
Manuel Costa and
Jean-Philippe Martin Better bug reporting with better privacy 319--328
Shan Lu and
Soyeon Park and
Eunsoo Seo and
Yuanyuan Zhou Learning from mistakes: a comprehensive
study on real world concurrency bug
characteristics . . . . . . . . . . . . 329--339
Yu Ce and
Xu Zhen and
Sun Ji-zhou and
Meng Xiao-jing and
Huang Yan-yan and
Wu Hua-bei ParaModel: a visual modeling and code
skeleton generation system for
programming parallel applications . . . 4--10
Simone Campanoni and
Giovanni Agosta and
Stefano Crespi Reghizzi A parallel dynamic compiler for CIL
bytecode . . . . . . . . . . . . . . . . 11--20
Yang Yi Sui and
Jun Lin and
Xiao Tuo Zhang An automated refactoring tool for
dataflow visual programming language . . 21--28
James Hook and
Michael Sperber The ICFP developer conference 2008 . . . 3--4
Paul Frenger Hard Java . . . . . . . . . . . . . . . 5--9
Babak Falsafi and
Pascal Felber Introduction . . . . . . . . . . . . . . 10--10
Mark W. Bailey TRANSACT 2008 paper abstracts . . . . . 11--14
Vijay Menon and
Steven Balensiefer and
Tatiana Shpeisman and
Ali-Reza Adl-Tabatabai and
Richard L. Hudson and
Bratin Saha and
Adam Welc Single global lock semantics in a weakly
atomic STM . . . . . . . . . . . . . . . 15--26
Tachio Terauchi Checking race freedom via linear
programming . . . . . . . . . . . . . . 1--10
Koushik Sen Race directed random testing of
concurrent programs . . . . . . . . . . 11--21
Stephen M. Blackburn and
Kathryn S. McKinley Immix: a mark-region garbage collector
with space efficiency, fast collection,
and mutator performance . . . . . . . . 22--32
Filip Pizlo and
Erez Petrank and
Bjarne Steensgaard A study of concurrent real-time garbage
collectors . . . . . . . . . . . . . . . 33--44
Xi Wang and
Zhilei Xu and
Xuezheng Liu and
Zhenyu Guo and
Xiaoge Wang and
Zheng Zhang Conditional correlation analysis for
safe region-based memory management . . 45--55
Ahmed M. Amin and
Mithuna Thottethodi and
T. N. Vijaykumar and
Steven Wereley and
Stephen C. Jacobson Automatic volume management for
programmable microfluidics . . . . . . . 56--67
Hans-J. Boehm and
Sarita V. Adve Foundations of the C++ concurrency
memory model . . . . . . . . . . . . . . 68--78
Shan Shan Huang and
Yannis Smaragdakis Expressive and safe static reflection
with MorphJ . . . . . . . . . . . . . . 79--89
Louis-Noël Pouchet and
Cédric Bastoul and
Albert Cohen and
John Cavazos Iterative optimization in the polyhedral
model: part ii, multidimensional time 90--100
Uday Bondhugula and
Albert Hartono and
J. Ramanujam and
P. Sadayappan A practical automatic polyhedral
parallelizer and locality optimizer . . 101--113
Manjunath Kudlur and
Scott Mahlke Orchestrating the execution of stream
programs on multicore platforms . . . . 114--124
Martin Vechev and
Eran Yahav Deriving linearizable fine-grained
concurrent objects . . . . . . . . . . . 125--135
Armando Solar-Lezama and
Christopher Grant Jones and
Rastislav Bodik Sketching concurrent data structures . . 136--148
Zachary Anderson and
David Gay and
Rob Ennals and
Eric Brewer SharC: checking data sharing strategies
for multithreaded C . . . . . . . . . . 149--158
Patrick M. Rondon and
Ming Kawaguci and
Ranjit Jhala Liquid types . . . . . . . . . . . . . . 159--169
Xinyu Feng and
Zhong Shao and
Yuan Dong and
Yu Guo Certifying low-level programs with
hardware interrupts and preemptive
threads . . . . . . . . . . . . . . . . 170--182
Juan Chen and
Chris Hawblitzel and
Frances Perry and
Mike Emmi and
Jeremy Condit and
Derrick Coetzee and
Polyvios Pratikaki Type-preserving compilation for
large-scale optimizing object-oriented
compilers . . . . . . . . . . . . . . . 183--192
Stephen McCamant and
Michael D. Ernst Quantitative information flow as network
flow capacity . . . . . . . . . . . . . 193--205
Patrice Godefroid and
Adam Kiezun and
Michael Y. Levin Grammar-based whitebox fuzzing . . . . . 206--215
Fernando Magno Quintão Pereira and
Jens Palsberg Register allocation by puzzle solving 216--226
Sebastian Hack and
Gerhard Goos Copy coalescing by graph recoloring . . 227--237
Bin Xin and
William N. Sumner and
Xiangyu Zhang Efficient program execution indexing . . 238--248
Vineet Kahlon Bootstrapping: a technique for scalable
flow and context-sensitive pointer alias
analysis . . . . . . . . . . . . . . . . 249--259
Daniel von Dincklage and
Amer Diwan Explaining failures of program analyses 260--269
Isil Dillig and
Thomas Dillig and
Alex Aiken Sound, complete and scalable
path-sensitive analysis . . . . . . . . 270--280
Sumit Gulwani and
Saurabh Srivastava and
Ramarathnam Venkatesan Program analysis as constraint solving 281--292
Cormac Flanagan and
Stephen N. Freund and
Jaeheon Yi Velodrome: a sound and complete dynamic
atomicity checker for multithreaded
programs . . . . . . . . . . . . . . . . 293--303
Sigmund Cherem and
Trishul Chilimbi and
Sumit Gulwani Inferring locks for atomic sections . . 304--315
Ravi Chugh and
Jan W. Voung and
Ranjit Jhala and
Sorin Lerner Dataflow analysis for concurrent
programs using datarace detection . . . 316--326
Michal Wegiel and
Chandra Krintz XMem: type-safe, transparent, shared
memory for cross-runtime communication
and coordination . . . . . . . . . . . . 327--338
Nicolas Halbwachs and
Mathias Péron Discovering properties about arrays in
simple programs . . . . . . . . . . . . 339--348
Karen Zee and
Viktor Kuncak and
Martin Rinard Full functional verification of linked
data structures . . . . . . . . . . . . 349--361
Madanlal Musuvathi and
Shaz Qadeer Fair stateless model checking . . . . . 362--371
Rachid Guerraoui and
Thomas A. Henzinger and
Barbara Jobstmann and
Vasu Singh Model checking transactional memories 372--382
Joshua Auerbach and
David F. Bacon and
Rachid Guerraoui and
Jesper Honig Spring and
Jan Vitek Flexible task graphs: a unified
restricted thread programming model for
Java . . . . . . . . . . . . . . . . . . 1--11
Seong-Won Lee and
Soo-Mook Moon and
Seong-Moo Kim Enhanced hot spot detection heuristics
for embedded Java just-in-time compilers 13--22
Carmen Badea and
Alexandru Nicolau and
Alexander V. Veidenbaum Impact of JVM superoperators on energy
consumption in resource-constrained
embedded systems . . . . . . . . . . . . 23--30
Dietmar Ebner and
Florian Brandner and
Bernhard Scholz and
Andreas Krall and
Peter Wiedermann and
Albrecht Kadlec Generalized instruction selection using
SSA-graphs . . . . . . . . . . . . . . . 31--40
Doosan Cho and
Sudeep Pasricha and
Ilya Issenin and
Nikil Dutt and
Yunheung Paek and
SunJun Ko Compiler driven data layout optimization
for regular/irregular array access
patterns . . . . . . . . . . . . . . . . 41--50
Jan Reineke and
Daniel Grund Relative competitive analysis of cache
replacement policies . . . . . . . . . . 51--60
Madhukar Anand and
Insup Lee Robust and sustainable schedulability
analysis of embedded software . . . . . 61--70
Houman Homayoun and
Sudeep Pasricha and
Mohammad Makhzan and
Alex Veidenbaum Improving performance and reducing
energy-delay with adaptive resource
resizing for out-of-order embedded
processors . . . . . . . . . . . . . . . 71--78
Sanjay Rajopadhye and
Gautam Gupta and
Lakshminarayanan Renganarayanan A domain specific interconnect for
reconfigurable computing . . . . . . . . 79--88
Jaejin Lee and
Junghyun Kim and
Choonki Jang and
Seungkyun Kim and
Bernhard Egger and
Kwangsub Kim and
SangYong Han FaCSim: a fast and cycle-accurate
architecture simulator for embedded
systems . . . . . . . . . . . . . . . . 89--100
Gwenaël Delaval and
Alain Girault and
Marc Pouzet A type system for the automatic
distribution of higher-order synchronous
dataflow programs . . . . . . . . . . . 101--110
Norman H. Cohen and
Karl Trygve Kalleberg EventScript: an event-processing
language based on regular expressions
with actions . . . . . . . . . . . . . . 111--120
Dariusz Biernacki and
Jean-Louis Colaço and
Gregoire Hamon and
Marc Pouzet Clock-directed modular code generation
for synchronous data-flow languages . . 121--130
Ryan R. Newton and
Lewis D. Girod and
Michael B. Craig and
Samuel R. Madden and
John Gregory Morrisett Design and evaluation of a compiler for
embedded stream programs . . . . . . . . 131--140
Mounira Bachir and
Sid-Ahmed-Ali Touati and
Albert Cohen Post-pass periodic register allocation
to minimise loop unrolling degree . . . 141--150
Bjorn De Sutter and
Paul Coene and
Tom Vander Aa and
Bingfeng Mei Placement-and-routing-based register
allocation for coarse-grained
reconfigurable arrays . . . . . . . . . 151--160
Li Wang and
Xuejun Yang and
Jingling Xue and
Yu Deng and
Xiaobo Yan and
Tao Tang and
Quan Hoang Nguyen Optimizing scientific application loops
on stream processors . . . . . . . . . . 161--170
Kathryn S. McKinley Improving publication quality by
reducing bias with double-blind
reviewing and author response . . . . . 5--9
Richard Jones and
Steve Blackburn International Symposium of Memory
Management (ISMM 2008) . . . . . . . . . 12--14
Mark W. Bailey ISMM 2008 paper abstracts . . . . . . . 15--19
Butler W. Lampson Lazy and speculative execution in
computer systems . . . . . . . . . . . . 1--2
James Cheney FLUX: functional updates for XML . . . . 3--14
Giuseppe Castagna and
Kim Nguyen Typed iterators for XML . . . . . . . . 15--26
Limin Jia and
Jeffrey A. Vaughan and
Karl Mazurak and
Jianzhou Zhao and
Luke Zarko and
Joseph Schorr and
Steve Zdancewic AURA: a programming language for
authorization and audit . . . . . . . . 27--38
Nicolas Oury and
Wouter Swierstra The power of Pi . . . . . . . . . . . . 39--50
Tom Schrijvers and
Simon Peyton Jones and
Manuel Chakravarty and
Martin Sulzmann Type checking with open type functions 51--62
Didier Rémy and
Boris Yakobowski From ML to ML$^F$: graphic type
constraints with efficient type
inference . . . . . . . . . . . . . . . 63--74
Louis-Julien Guillemette and
Stefan Monnier A type-preserving compiler in Haskell 75--86
Mark P. Jones Experience report: playing the DSL card 87--90
Fritz Henglein Generic discrimination: sorting and
partitioning unshared data in linear
time . . . . . . . . . . . . . . . . . . 91--102
Laura Effinger-Dean and
Matthew Kehrt and
Dan Grossman Transactional events for ML . . . . . . 103--114
Christian Convey and
Andrew Fredricks and
Christopher Gagner and
Douglas Maxwell and
Lutz Hamel Experience report: Erlang in acoustic
ray tracing . . . . . . . . . . . . . . 115--118
Matthew Fluet and
Mike Rainey and
John Reppy and
Adam Shaw Implicitly-threaded parallelism in
Manticore . . . . . . . . . . . . . . . 119--130
Olivier Danvy Defunctionalized interpreters for
programming languages . . . . . . . . . 131--142
Adam Chlipala Parametric higher-order abstract syntax
for mechanized semantics . . . . . . . . 143--156
Amal Ahmed and
Matthias Blume Typed closure conversion preserves
observational equivalence . . . . . . . 157--168
Akimasa Morihata and
Kiminori Matsuzaki and
Masato Takeichi Write it recursively: a generic
framework for optimal path queries . . . 169--178
Michael D. Adams and
R. Kent Dybvig Efficient nondestructive equality
checking for trees and graphs . . . . . 179--188
Ralf Hinze Functional pearl: streams and unique
fixed points . . . . . . . . . . . . . . 189--200
Sebastian Fischer and
Herbert Kuchen Data-flow testing of declarative
programs . . . . . . . . . . . . . . . . 201--212
Arthur Charguéraud and
François Pottier Functional translation of a calculus of
capabilities . . . . . . . . . . . . . . 213--224
Lennart Augustsson and
Howard Mansell and
Ganesh Sittampalam Paradise: a two-stage DSL embedded in
Haskell . . . . . . . . . . . . . . . . 225--228
Aleksandar Nanevski and
Greg Morrisett and
Avraham Shinnar and
Paul Govereau and
Lars Birkedal Ynot: dependent types for imperative
programs . . . . . . . . . . . . . . . . 229--240
Matthew Fluet and
Mike Rainey and
John Reppy A scheduling framework for
general-purpose parallel languages . . . 241--252
Daniel Spoonhower and
Guy E. Blelloch and
Robert Harper and
Phillip B. Gibbons Space profiling for parallel functional
programs . . . . . . . . . . . . . . . . 253--264
Mark P. Jones Polymorphism and page tables: systems
programming from a functional
programmer's perspective . . . . . . . . 265--266
Alexander Krauss Pattern minimization problems over
recursive data types . . . . . . . . . . 267--274
David Van Horn and
Harry G. Mairson Deciding $k$ CFA is complete for EXPTIME 275--282
Daan Leijen HMF: simple type inference for
first-class polymorphism . . . . . . . . 283--294
Dimitrios Vytiniotis and
Stephanie Weirich and
Simon Peyton Jones FPH: first-class polymorphism for
Haskell . . . . . . . . . . . . . . . . 295--306
Derek Dreyer and
Andreas Rossberg Mixin' up the ML module system . . . . . 307--320
Ruy Ley-Wild and
Matthew Fluet and
Umut A. Acar Compiling self-adjusting programs with
continuations . . . . . . . . . . . . . 321--334
Geoffrey Mainland and
Greg Morrisett and
Matt Welsh Flask: staged functional programming for
sensor networks . . . . . . . . . . . . 335--346
Ravi Nanavati Experience report: a pure shirt fits . . 347--352
Sungwoo Park and
Jinha Kim and
Hyeonseung Im Functional netlists . . . . . . . . . . 353--366
Eelco Dolstra and
Andres Löh NixOS: a purely functional Linux
distribution . . . . . . . . . . . . . . 367--378
David J. Duke and
Rita Borgo and
Colin Runciman and
Malcolm Wallace Experience report: visualizing data
through functional pipelines . . . . . . 379--382
J. Nathan Foster and
Alexandre Pilkiewicz and
Benjamin C. Pierce Quotient lenses . . . . . . . . . . . . 383--396
Eelco Dolstra and
Jurriaan Hage and
Bastiaan Heeren and
Stefan Holdermans and
Johan Jeuring and
Andres Löh and
Clara Löh and
Arie Middelkoop and
Alexey Rodriguez and
John van Schie Report on the Tenth ICFP Programming
Contest . . . . . . . . . . . . . . . . 397--408
Darren Willis and
David J. Pearce and
James Noble Caching and incrementalisation in the
Java Query Language . . . . . . . . . . 1--18
Ben Wiedermann and
Ali Ibrahim and
William R. Cook Interprocedural query extraction for
transparent persistence . . . . . . . . 19--36
Zachary Tatlock and
Chris Tucker and
David Shuffelton and
Ranjit Jhala and
Sorin Lerner Deep typechecking and refactoring . . . 37--52
Claudio V. Russo Join patterns for Visual Basic . . . . . 53--72
Joseph Gil and
Itay Maman Whiteoak: introducing structural typing
into Java . . . . . . . . . . . . . . . 73--90
Lennart C. L. Kats and
Martin Bravenboer and
Eelco Visser Mixing source and bytecode: a case for
compilation by normalization . . . . . . 91--108
Michael D. Bond and
Kathryn S. McKinley Tolerating memory leaks . . . . . . . . 109--126
Ajeet Shankar and
Matthew Arnold and
Rastislav Bodik Jolt: lightweight dynamic analysis and
removal of object churn . . . . . . . . 127--142
Matthew Arnold and
Martin Vechev and
Eran Yahav QVM: an efficient runtime for detecting
defects in deployed systems . . . . . . 143--162
Feng Xian and
Witawas Srisa-an and
Hong Jiang Contention-aware scheduler: unlocking
execution parallelism in multithreaded
Java programs . . . . . . . . . . . . . 163--180
Florian T. Schneider and
Vijay Menon and
Tatiana Shpeisman and
Ali-Reza Adl-Tabatabai Dynamic optimization for efficient
strong atomicity . . . . . . . . . . . . 181--194
Yang Ni and
Adam Welc and
Ali-Reza Adl-Tabatabai and
Moshe Bach and
Sion Berkowits and
James Cownie and
Robert Geva and
Sergey Kozhukow and
Ravi Narayanaswamy and
Jeffrey Olivier and
Serguei Preis and
Bratin Saha and
Ady Tal and
Xinmin Tian Design and implementation of
transactional constructs for C/C++ . . . 195--212
Dino Distefano and
Matthew J. Parkinson J. jStar: towards practical verification
for Java . . . . . . . . . . . . . . . . 213--226
Nels E. Beckman and
Kevin Bierhoff and
Jonathan Aldrich Verifying correct usage of atomic blocks
and typestate . . . . . . . . . . . . . 227--244
Madhu Gopinathan and
Sriram K. Rajamani Enforcing object protocols by combining
static and runtime analysis . . . . . . 245--260
Rick Chern and
Kris De Volder The impact of static-dynamic coupling on
remodularization . . . . . . . . . . . . 261--276
Max Schäfer and
Torbjörn Ekman and
Oege de Moor Sound and extensible renaming for Java 277--294
Wesley Tansey and
Eli Tilevich Annotation refactoring: inferring
upgrade transformations for legacy
applications . . . . . . . . . . . . . . 295--312
Barthélémy Dagenais and
Laurie Hendren Enabling static analysis for partial
Java programs . . . . . . . . . . . . . 313--328
Pietro Ferrara and
Francesco Logozzo and
Manuel Fahndrich Safer unsafe code for .NET . . . . . . . 329--346
Nomair A. Naeem and
Ondrej Lhotak Typestate-like analysis of multiple
interacting objects . . . . . . . . . . 347--366
Andy Georges and
Lieven Eeckhout and
Dries Buytaert Java performance evaluation through
rigorous replay compilation . . . . . . 367--384
Kiyokuni Kawachiya and
Kazunori Ogata and
Tamiya Onodera Analysis and reduction of memory
inefficiencies in Java strings . . . . . 385--402
Gregory B. Prokopski and
Clark Verbrugge Analyzing the performance of
code-copying virtual machines . . . . . 403--422
Adriaan Moors and
Frank Piessens and
Martin Odersky Generics of a higher kind . . . . . . . 423--438
Bruno C.d.S. Oliveira and
Meng Wang and
Jeremy Gibbons The visitor pattern as a reusable,
generic, type-safe component . . . . . . 439--456
Nathaniel Nystrom and
Vijay Saraswat and
Jens Palsberg and
Christian Grothoff Constrained types for object-oriented
languages . . . . . . . . . . . . . . . 457--474
Ben Bellamy and
Pavel Avgustinov and
Oege de Moor and
Damien Sereni Efficient local type inference . . . . . 475--492
Michael Roberson and
Melanie Harries and
Paul T. Darga and
Chandrasekhar Boyapati Efficient software model checking of
soundness of type systems . . . . . . . 493--504
Daniel Smith and
Robert Cartwright Java type inference is broken: can we
fix it? . . . . . . . . . . . . . . . . 505--524
Hans Schippers and
Dirk Janssens and
Michael Haupt and
Robert Hirschfeld Delegation-based semantics for
modularizing crosscutting concerns . . . 525--542
Pierre F. Baldi and
Cristina V. Lopes and
Erik J. Linstead and
Sushil K. Bajracharya A theory of aspects as latent topics . . 543--562
Radu Muschevici and
Alex Potanin and
Ewan Tempero and
James Noble Multiple dispatch in practice . . . . . 563--582
Eric Bouillet and
Mark Feblowitz and
Zhen Liu and
Anand Ranganathan and
Anton Riabov A tag-based approach for the design and
composition of information processing
applications . . . . . . . . . . . . . . 585--602
Christopher Simpkins and
Sooraj Bhat and
Charles Isbell, Jr. and
Michael Mateas Towards adaptive programming:
integrating reinforcement learning into
a programming language . . . . . . . . . 603--614
Richard P. Gabriel Designed as designer . . . . . . . . . . 617--632
Mark W. Bailey SIGPLAN programming language curriculum
workshop: Workshop organization . . . . 1--6
Mark W. Bailey SIGPLAN programming language curriculum
workshop: Discussion Summaries and
recommendations . . . . . . . . . . . . 6--29
Mark W. Bailey SIGPLAN programming language curriculum
workshop: Workshop report summary . . . 29--30
Eric Allen Some things that computer science majors
should know . . . . . . . . . . . . . . 32--35
Mark W. Bailey Injecting programming language concepts
throughout the curriculum: an inclusive
strategy . . . . . . . . . . . . . . . . 36--38
Rastislav Bodik Small languages in an undergraduate
PL/Compiler course . . . . . . . . . . . 39--44
Kim Bruce and
Stephen N. Freund Programming languages in a liberal arts
education . . . . . . . . . . . . . . . 45--49
Kim Bruce and
Stephen N. Freund Programming languages as part of core
computer science . . . . . . . . . . . . 50--54
William R. Cook High-level problems in teaching
undergraduate programming languages . . 55--58
Matthias Felleisen Why teach programming languages in this
day and age and how to go about it . . . 59--61
Kathleen Fisher We need more than one: why students need
a sophisticated understanding of
programming languages . . . . . . . . . 62--65
Kathi Fisler Implementing domain-specific languages
as the foundation of an honors intro CS
course . . . . . . . . . . . . . . . . . 66--70
Robert Harper Position paper: practical foundations
for programming languages . . . . . . . 71--73
Michael Hind Addressing the disconnect between the
good and the popular . . . . . . . . . . 74--76
John Hughes Experiences from teaching functional
programming at Chalmers . . . . . . . . 77--80
Shriram Krishnamurthi Teaching programming languages in a
post-Linnaean age . . . . . . . . . . . 81--83
James Larus PL research and its consequences on PL
curriculum . . . . . . . . . . . . . . . 84--86
Doug Lea and
David F. Bacon and
David Grove Languages and performance engineering:
method, instrumentation, and pedagogy 87--92
Gary T. Leavens Use concurrent programming models to
motivate teaching of programming
languages . . . . . . . . . . . . . . . 93--98
Lori Pollock Rethinking pedagogy for teaching PL with
more than PL concepts in mind . . . . . 99--103
Stuart Reges Marketing the programming languages
course . . . . . . . . . . . . . . . . . 104--107
John C. Reynolds Some thoughts on teaching programming
and programming languages . . . . . . . 108--110
Martin Rinard Using programming language concepts to
teach general thinking skills . . . . . 111--118
Peter Sestoft Programming language concepts for
software developers . . . . . . . . . . 119--123
Mark A. Sheldon and
Franklyn Turbak An aspect-oriented approach to the
undergraduate programming language
curriculum . . . . . . . . . . . . . . . 124--129
Olin Shivers Why teach programming languages . . . . 130--132
Mitchell Wand and
Daniel P. Friedman Programming languages: fundamental
concepts for expanding and disciplining
the mind . . . . . . . . . . . . . . . . 133--135
Marco Pistoia and
Úlfar Erlingsson Workshop on Programming Languages and
Analysis for Security (PLAS 2008) . . . 3--4
Marco Pistoia and
Úlfar Erlingsson PLAS 2008 paper abstracts . . . . . . . 5--8
Avik Chaudhuri and
Prasad Naldurg and
Sriram Rajamani A type system for data-flow integrity on
Windows Vista . . . . . . . . . . . . . 9--20
Nikhil Swamy and
Michael Hicks Verified enforcement of stateful
information release policies . . . . . . 21--31
Marco Pistoia and
Úlfar Erlingsson Programming languages and program
analysis for security: a three-year
retrospective . . . . . . . . . . . . . 32--39
Tim Harris Language constructs for transactional
memory . . . . . . . . . . . . . . . . . 1--1
Tayfun Elmas and
Shaz Qadeer and
Serdar Tasiran A calculus of atomic actions . . . . . . 2--15
Alexey Gotsman and
Byron Cook and
Matthew Parkinson and
Viktor Vafeiadis Proving that non-blocking algorithms
don't block . . . . . . . . . . . . . . 16--28
Martin Abadi and
Gordon Plotkin A model of cooperative threads . . . . . 29--40
Dana N. Xu and
Simon Peyton Jones and
Koen Claessen Static contract checking for Haskell . . 41--52
Xin Qi and
Andrew C. Myers Masked types for sound object
initialization . . . . . . . . . . . . . 53--65
Daan Leijen Flexible types: robust type inference
for first-class polymorphism . . . . . . 66--77
Roberto Lublinerman and
Christian Szegedy and
Stavros Tripakis Modular code generation from synchronous
block diagrams: modularity vs. code size 78--89
Gilles Barthe and
Benjamin Grégoire and
Santiago Zanella Béguelin Formal certification of code-based
cryptographic proofs . . . . . . . . . . 90--101
Pierre Ganty and
Rupak Majumdar and
Andrey Rybalchenko Verifying liveness for asynchronous
programs . . . . . . . . . . . . . . . . 102--113
Julien Brunel and
Damien Doligez and
René Rydhof Hansen and
Julia L. Lawall and
Gilles Muller A foundation for flow-based program
matching: using temporal logic and model
checking . . . . . . . . . . . . . . . . 114--126
Sumit Gulwani and
Krishna K. Mehra and
Trishul Chilimbi SPEED: precise and efficient static
estimation of program computational
complexity . . . . . . . . . . . . . . . 127--139
David P. Monniaux Automatic modular abstractions for
linear constraints . . . . . . . . . . . 140--151
Chris Barker Wild control operators . . . . . . . . . 152--152
Ronald Garcia and
Andrew Lumsdaine and
Amr Sabry Lazy evaluation and delimited control 153--164
Janis Voigtländer Bidirectionalization for free! (Pearl) 165--176
Akimasa Morihata and
Kiminori Matsuzaki and
Zhenjiang Hu and
Masato Takeichi The third homomorphism theorem on trees:
downward & upward lead to
divide-and-conquer . . . . . . . . . . . 177--185
Ruy Ley-Wild and
Umut A. Acar and
Matthew Fluet A cost semantics for self-adjusting
computation . . . . . . . . . . . . . . 186--199
Akihiko Tozawa and
Michiaki Tatsubori and
Tamiya Onodera and
Yasuhiko Minamide Copy-on-write in the PHP language . . . 200--212
Nathan G. Bronson and
Christos Kozyrakis and
Kunle Olukotun Feedback-directed barrier optimization
in a strongly isolated STM . . . . . . . 213--225
Ben Hardekopf and
Calvin Lin Semi-sparse flow-sensitive pointer
analysis . . . . . . . . . . . . . . . . 226--238
Sumit Gulwani and
Tal Lev-Ami and
Mooly Sagiv A combination framework for tracking
partition sizes . . . . . . . . . . . . 239--251
Yin Wang and
Stéphane Lafortune and
Terence Kelly and
Manjunath Kudlur and
Scott Mahlke The theory of deadlock avoidance via
discrete control . . . . . . . . . . . . 252--263
Ross Tate and
Michael Stepp and
Zachary Tatlock and
Sorin Lerner Equality saturation: a new approach to
optimization . . . . . . . . . . . . . . 264--276
Peter A. Jonsson and
Johan Nordlander Positive supercompilation for a higher
order call-by-value language . . . . . . 277--288
Cristiano Calcagno and
Dino Distefano and
Peter O'Hearn and
Hongseok Yang Compositional shape analysis by means of
bi-abduction . . . . . . . . . . . . . . 289--300
Alex Simpson Linear types for computational effects 301--301
Jeremy Condit and
Brian Hackett and
Shuvendu K. Lahiri and
Shaz Qadeer Unifying type checking and property
checking for low-level code . . . . . . 302--314
Xinyu Feng Local rely-guarantee reasoning . . . . . 315--327
James Brotherston and
Cristiano Calcagno Classical BI: a logic for reasoning
about dualising resources . . . . . . . 328--339
Amal Ahmed and
Derek Dreyer and
Andreas Rossberg State-dependent representation
independence . . . . . . . . . . . . . . 340--353
Beno\^\it Montagu and
Didier Rémy Modeling abstract types in modules with
open existential types . . . . . . . . . 354--365
Neelakantan R. Krishnaswami Focusing on pattern matching . . . . . . 366--378
Susmit Sarkar and
Peter Sewell and
Francesco Zappa Nardelli and
Scott Owens and
Tom Ridge and
Thomas Braibant and
Magnus O. Myreen and
Jade Alglave The semantics of x86-CC multiprocessor
machine code . . . . . . . . . . . . . . 379--391
Gérard Boudol and
Gustavo Petri Relaxed memory models: an operational
approach . . . . . . . . . . . . . . . . 392--403
Rachid Guerraoui and
Michal Kapalka The semantics of progress in lock-based
transactional memory . . . . . . . . . . 404--415
Naoki Kobayashi Types and higher-order recursion schemes
for verification of higher-order
programs . . . . . . . . . . . . . . . . 416--428
Thomas Ridge Verifying distributed systems: the
operational approach . . . . . . . . . . 429--440
Chris Hawblitzel and
Erez Petrank Automated verification of practical
garbage collectors . . . . . . . . . . . 441--453
Oleg Kiselyov and
Chung-chieh Shan Lightweight monadic regions . . . . . . 1--12
Alejandro Russo and
Koen Claessen and
John Hughes A library for light-weight
information-flow security in haskell . . 13--24
Riccardo Pucella and
Jesse A. Tov Haskell session types with (almost) no
class . . . . . . . . . . . . . . . . . 25--36
Colin Runciman and
Matthew Naylor and
Fredrik Lindblad SmallCheck and Lazy SmallCheck:
automatic exhaustive testing for small
values . . . . . . . . . . . . . . . . . 37--48
Neil Mitchell and
Colin Runciman Not all patterns, but enough: an
automatic verifier for partial but
sufficient pattern matching . . . . . . 49--60
Jean-Philippe Bernardy Yi: an editor in Haskell for Haskell . . 61--62
Marcos Viera and
S. Doaitse Swierstra and
Eelco Lempsink Haskell, do you read me?: constructing
and composing efficient top-down parsers
at runtime . . . . . . . . . . . . . . . 63--74
Ki Yung Ahn and
Tim Sheard Shared subtypes: subtyping recursive
parametrized algebraic data types . . . 75--86
Mark P. Jones and
Iavor S. Diatchki Language and program design for
functional dependencies . . . . . . . . 87--98
Pericles S. Kariotis and
Adam M. Procter and
William L. Harrison Making monads first-class with Template
Haskell . . . . . . . . . . . . . . . . 99--110
Alexey Rodriguez and
Johan Jeuring and
Patrik Jansson and
Alex Gerdes and
Oleg Kiselyov and
Bruno C. d. S. Oliveira Comparing libraries for generic
programming in haskell . . . . . . . . . 111--122
Tristan O. R. Allwood and
Susan Eisenbach CLASE: cursor library for a structured
editor . . . . . . . . . . . . . . . . . 123--124
Duncan Coutts and
Isaac Potoczny-Jones and
Don Stewart Haskell: batteries included . . . . . . 125--126
Mark Gebhart and
Bertrand A. Maher and
Katherine E. Coons and
Jeff Diamond and
Paul Gratz and
Mario Marino and
Nitya Ranganathan and
Behnam Robatmili and
Aaron Smith and
James Burrill and
Stephen W. Keckler and
Doug Burger and
Kathryn S. McKinley An evaluation of the TRIPS computer
system . . . . . . . . . . . . . . . . . 1--12
Constantin Pistol and
Wutichai Chongchitmate and
Christopher Dwyer and
Alvin R. Lebeck Architectural implications of nanoscale
integrated sensing and computing . . . . 13--24
Soyeon Park and
Shan Lu and
Yuanyuan Zhou CTrigger: exposing atomicity violation
bugs from their hiding places . . . . . 25--36
Stelios Sidiroglou and
Oren Laadan and
Carlos Perez and
Nicolas Viennot and
Jason Nieh and
Angelos D. Keromytis ASSURE: automatic software self-healing
using rescue points . . . . . . . . . . 37--48
Andrew Lenharth and
Vikram S. Adve and
Samuel T. King Recovery domains: an organizing
principle for recoverable operating
systems . . . . . . . . . . . . . . . . 49--60
Martin Dimitrov and
Huiyang Zhou Anomaly-based bug prediction, isolation,
and validation: an automated approach
for software debugging . . . . . . . . . 61--72
Pablo Montesinos and
Matthew Hicks and
Samuel T. King and
Josep Torrellas Capo: a software-hardware interface for
practical deterministic multiprocessor
replay . . . . . . . . . . . . . . . . . 73--84
Joseph Devietti and
Brandon Lucia and
Luis Ceze and
Mark Oskin DMP: deterministic shared memory
multiprocessing . . . . . . . . . . . . 85--96
Marek Olszewski and
Jason Ansel and
Saman Amarasinghe Kendo: efficient deterministic
multithreading in software . . . . . . . 97--108
Mohit Tiwari and
Hassan M. G. Wassel and
Bita Mazloom and
Shashidhar Mysore and
Frederic T. Chong and
Timothy Sherwood Complete information flow tracking from
the gates up . . . . . . . . . . . . . . 109--120
David K. Tam and
Reza Azimi and
Livio B. Soares and
Michael Stumm RapidMRC: approximating L2 miss rate
curves on commodity systems for online
optimizations . . . . . . . . . . . . . 121--132
Stijn Eyerman and
Lieven Eeckhout Per-thread cycle accounting in SMT
processors . . . . . . . . . . . . . . . 133--144
Owen S. Hofmann and
Christopher J. Rossbach and
Emmett Witchel Maximum benefit from a minimal HTM . . . 145--156
Dave Dice and
Yossi Lev and
Mark Moir and
Daniel Nussbaum Early experience with a commercial
hardware transactional memory
implementation . . . . . . . . . . . . . 157--168
Philip M. Wells and
Koushik Chakraborty and
Gurindar S. Sohi Mixed-mode multicore reliability . . . . 169--180
Sriram Rajamani and
G. Ramalingam and
Venkatesh Prasad Ranganath and
Kapil Vaswani ISOLATOR: dynamically ensuring isolation
in concurrent programs . . . . . . . . . 181--192
Joseph Tucek and
Weiwei Xiong and
Yuanyuan Zhou Efficient online validation with delta
execution . . . . . . . . . . . . . . . 193--204
David Meisner and
Brian T. Gold and
Thomas F. Wenisch PowerNap: eliminating server idle power 205--216
Adrian M. Caulfield and
Laura M. Grupp and
Steven Swanson Gordon: using flash memory to build
fast, power-efficient clusters for
data-intensive applications . . . . . . 217--228
Aayush Gupta and
Youngjae Kim and
Bhuvan Urgaonkar DFTL: a flash translation layer
employing demand-based selective caching
of page-level address mappings . . . . . 229--240
Farhana Aleen and
Nathan Clark Commutativity analysis for software
parallelization: letting program
transformations see the big picture . . 241--252
M. Aater Suleman and
Onur Mutlu and
Moinuddin K. Qureshi and
Yale N. Patt Accelerating critical section execution
with asymmetric multi-core architectures 253--264
Todd Mytkowicz and
Amer Diwan and
Matthias Hauswirth and
Peter F. Sweeney Producing wrong data without doing
anything obviously wrong! . . . . . . . 265--276
Michael D. Bond and
Kathryn S. McKinley Leak pruning . . . . . . . . . . . . . . 277--288
Michal Wegiel and
Chandra Krintz Dynamic prediction of collection yield
for managed runtimes . . . . . . . . . . 289--300
Aravind Menon and
Simon Schubert and
Willy Zwaenepoel TwinDrivers: semi-automatic derivation
of fast and safe hypervisor network
drivers from guest OS drivers . . . . . 301--312
Ioana Burcea and
Andreas Moshovos Phantom-BTB: a virtualized branch target
buffer design . . . . . . . . . . . . . 313--324
Karthik Ramani and
Christiaan P. Gribble and
Al Davis StreamRay: a stream filtering
architecture for coherent ray tracing 325--336
Robert D. Cameron and
Dan Lin Architectural support for SWAR text
processing with parallel bit streams:
the inductive doubling principle . . . . 337--348
Guy E. Blelloch Parallel thinking . . . . . . . . . . . 1--2
Milind Kulkarni and
Martin Burtscher and
Rajeshkar Inkulu and
Keshav Pingali and
Calin Casçaval How much parallelism is there in
irregular applications? . . . . . . . . 3--14
Seunghwa Kang and
David A. Bader An efficient transactional memory
algorithm for computing minimum spanning
forest of sparse graphs . . . . . . . . 15--24
Ferad Zyulkyarov and
Vladimir Gajinov and
Osman S. Unsal and
Adrián Cristal and
Eduard Ayguadé and
Tim Harris and
Mateo Valero Atomic quake: using transactional memory
in an interactive multiplayer game
server . . . . . . . . . . . . . . . . . 25--34
Siu Yau and
Vijay Karamcheti and
Denis Zorin and
Kostadin Damevski and
Steven G. Parker Application-aware management of parallel
simulation collections . . . . . . . . . 35--44
Maged M. Michael and
Martin T. Vechev and
Vijay A. Saraswat Idempotent work stealing . . . . . . . . 45--54
Tasuku Hiraishi and
Masahiro Yasugi and
Seiji Umatani and
Taiichi Yuasa Backtracking-based load balancing . . . 55--64
Tong Li and
Dan Baumberger and
Scott Hahn Efficient and scalable multiprocessor
fair scheduling using distributed
weighted round-robin . . . . . . . . . . 65--74
Zheng Wang and
Michael F. P. O'Boyle Mapping parallelism to multi-cores: a
machine learning based approach . . . . 75--84
Matthew D. Allen and
Srinath Sridharan and
Gurindar S. Sohi Serialization sets: a dynamic
dependence-based parallel execution
model . . . . . . . . . . . . . . . . . 85--96
Mark D. Hill Opportunities beyond single-core
microprocessors . . . . . . . . . . . . 97--97
Yale N. Patt Multi-core demands multi-interfaces . . 99--100
Seyong Lee and
Seung-Jai Min and
Rudolf Eigenmann OpenMP to GPGPU: a compiler framework
for automatic translation and
optimization . . . . . . . . . . . . . . 101--110
Xuejun Yang and
Li Wang and
Jingling Xue and
Yu Deng and
Ying Zhang Comparability graph coloring for
optimizing utilization of stream
register files in stream processors . . 111--120
Gregorio Quintana-Ortí and
Francisco D. Igual and
Enrique S. Quintana-Ortí and
Robert A. van de Geijn Solving dense linear systems on
platforms with multiple hardware
accelerators . . . . . . . . . . . . . . 121--130
Scott Schneider and
Jae-Seung Yeom and
Benjamin Rose and
John C. Linford and
Adrian Sandu and
Dimitrios S. Nikolopoulos A comparison of programming models for
multiprocessors with explicitly managed
memory hierarchies . . . . . . . . . . . 131--140
Michael F. Spear and
Luke Dalessandro and
Virendra J. Marathe and
Michael L. Scott A comprehensive strategy for contention
management in software transactional
memory . . . . . . . . . . . . . . . . . 141--150
Kunal Agrawal and
I-Ting Angelina Lee and
Jim Sukha Safe open-nested transactions through
ownership . . . . . . . . . . . . . . . 151--162
Hany E. Ramadan and
Indrajit Roy and
Maurice Herlihy and
Emmett Witchel Committing conflicting transactions in
an STM . . . . . . . . . . . . . . . . . 163--172
Paruj Ratanaworabhan and
Martin Burtscher and
Darko Kirovski and
Benjamin Zorn and
Rahul Nagpal and
Karthik Pattabiraman Detecting and tolerating asymmetric
races . . . . . . . . . . . . . . . . . 173--184
Martín Abadi and
Tim Harris and
Mojtaba Mehrara Transactional memory with strong
atomicity using off-the-shelf memory
protection hardware . . . . . . . . . . 185--196
Parthasarathy Ranganathan Industrial perspectives panel . . . . . 197--197
Alexandru Nicolau and
Guangqiang Li and
Arun Kejariwal Techniques for efficient placement of
synchronization primitives . . . . . . . 199--208
Seung Woo Son and
Mahmut Kandemir and
Mustafa Karakoy and
Dhruva Chakrabarti A compiler-directed data prefetching
scheme for chip multiprocessors . . . . 209--218
Muthu Manikandan Baskaran and
Nagavijayalakshmi Vydyanathan and
Uday Kumar Reddy Bondhugula and
J. Ramanujam and
Atanas Rountev and
P. Sadayappan Compiler-assisted dynamic scheduling for
effective parallelization of loop nests
on multicore processors . . . . . . . . 219--228
Nathan R. Tallent and
John M. Mellor-Crummey Effective performance measurement and
analysis of multithreaded applications 229--240
Michael Kistler and
John Gunnels and
Daniel Brokenshire and
Brad Benton Petascale computing with accelerators 241--250
Ruini Xue and
Xuezheng Liu and
Ming Wu and
Zhenyu Guo and
Wenguang Chen and
Weimin Zheng and
Zheng Zhang and
Geoffrey Voelker MPIWiz: subgroup reproducible replay of
MPI applications . . . . . . . . . . . . 251--260
Anh Vo and
Sarvani Vakkalanka and
Michael DeLisi and
Ganesh Gopalakrishnan and
Robert M. Kirby and
Rajeev Thakur Formal verification of practical MPI
programs . . . . . . . . . . . . . . . . 261--270
Ganesh Bikshandi and
Jose G. Castanos and
Sreedhar B. Kodali and
V. Krishna Nandivada and
Igor Peshansky and
Vijay A. Saraswat and
Sayantan Sur and
Pradeep Varma and
Tong Wen Efficient, portable implementation of
asynchronous multi-place programs . . . 271--282
Jack B. Dennis How to build programmable multi-core
chips . . . . . . . . . . . . . . . . . 283--284
Guoping Long and
Dongrui Fan and
Junchao Zhang Architectural support for Cilk
computations on many-core architectures 285--286
Wenjing Ma and
Gagan Agrawal A compiler and runtime system for
enabling data mining applications on
GPUs . . . . . . . . . . . . . . . . . . 287--288
Lei Huang and
Deepak Eachempati and
Marcus W. Hervey and
Barbara Chapman Exploiting global optimizations for
OpenMP programs in the OpenUH compiler 289--290
Haris Volos and
Adam Welc and
Ali-Reza Adl-Tabatabai and
Tatiana Shpeisman and
Xinmin Tian and
Ravi Narayanaswamy NePalTM: design and implementation of
nested parallelism for transactional
memory systems . . . . . . . . . . . . . 291--292
Arun Kejariwal and
Calin Casçaval Parallelization spectroscopy: analysis
of thread-level parallelism in HPC
programs . . . . . . . . . . . . . . . . 293--294
Phuong Hoai Ha and
Philippas Tsigas and
Otto J. Anshus Preliminary results on NB-FEB, a
synchronization primitive for parallel
programming . . . . . . . . . . . . . . 295--296
Alokika Dash and
Brian Demsky Software transactional distributed
shared memory . . . . . . . . . . . . . 297--298
Ke Yang and
Bingsheng He and
Qiong Luo and
Pedro V. Sander and
Jiaoying Shi Stack-based parallel recursion on
graphics processors . . . . . . . . . . 299--300
Abhinav Bhatelé and
Eric Bohm and
Laxmikant V. Kalé Topology aware task mapping techniques:
an API and case study . . . . . . . . . 301--302
Shane A. Markstrum and
Robert M. Fuhrer and
Todd D. Millstein Towards concurrency refactoring for X10 303--304
Stephen L. Scott and
Christian Engelmann and
Geoffroy R. Vallée and
Thomas Naughton and
Anand Tikotekar and
George Ostrouchov and
Chokchai Leangsuksun and
Nichamon Naksinehaboon and
Raja Nassar and
Mihaela Paun and
Frank Mueller and
Chao Wang and
Arun B. Nagarajan and
Jyothish Varma A tunable holistic resiliency approach
for high-performance computing systems 305--306
Chinmay Eishan Kulkarni and
Osman Unsal and
Adrián Cristal and
Eduard Ayguadé and
Mateo Valero Turbocharging boosted transactions or:
how I learnt to stop worrying and love
longer transactions . . . . . . . . . . 307--308
Jade Alglave and
Anthony Fox and
Samin Ishtiaq and
Magnus O. Myreen and
Susmit Sarkar and
Peter Sewell and
Francesco Zappa Nardelli The semantics of power and ARM
multiprocessor machine code (abstract
only) . . . . . . . . . . . . . . . . . 8--8
Lukasz Ziarek and
Suresh Jagannathan and
Matthew Fluet and
Umut A. Acar Speculative $N$-way barriers (abstract
only) . . . . . . . . . . . . . . . . . 8--8
Abdallah Deeb I. Al Zain and
Kevin Hammond and
Jost Berthold and
Phil Trinder and
Greg Michaelson and
Mustafa Aswad Low-pain, high-gain multicore
programming in Haskell: coordinating
irregular symbolic computations on
multicore architectures (abstract only) 8--9
Zoran Budimlic and
Aparna M. Chandramowlishwaran and
Kathleen Knobe and
Geoff N. Lowney and
Vivek Sarkar and
Leo Treggiari Declarative aspects of memory management
in the concurrent collections parallel
programming model (abstract only) . . . 9--9
Martin Sulzmann and
Edmund S. L. Lam and
Simon Marlow Comparing the performance of concurrent
linked-list implementations in Haskell
(abstract only) . . . . . . . . . . . . 9--9
Stephan Herhut and
Sven-Bodo Scholz and
Clemens Grelck Controlling chaos: on safe side-effects
in data-parallel operations (abstract
only) . . . . . . . . . . . . . . . . . 9--10
Martin Sulzmann and
Edmund S. L. Lam and
Simon Marlow Comparing the performance of concurrent
linked-list implementations in Haskell 11--20
Suriya Subramanian and
Michael Hicks and
Kathryn S. McKinley Dynamic software updates: a VM-centric
approach . . . . . . . . . . . . . . . . 1--12
Iulian Neamtiu and
Michael Hicks Safe and timely updates to
multi-threaded programs . . . . . . . . 13--24
Matthew A. Hammer and
Umut A. Acar and
Yan Chen CEAL: a C-based language for
self-adjusting computation . . . . . . . 25--37
Jason Ansel and
Cy Chan and
Yee Lok Wong and
Marek Olszewski and
Qin Zhao and
Alan Edelman and
Saman Amarasinghe PetaBricks: a language and compiler for
algorithmic choice . . . . . . . . . . . 38--49
Ravi Chugh and
Jeffrey A. Meister and
Ranjit Jhala and
Sorin Lerner Staged information flow for JavaScript 50--62
Indrajit Roy and
Donald E. Porter and
Michael D. Bond and
Kathryn S. McKinley and
Emmett Witchel Laminar: practical fine-grained
decentralized information flow control 63--74
Benjamin Livshits and
Aditya V. Nori and
Sriram K. Rajamani and
Anindya Banerjee Merlin: specification inference for
explicit information flow problems . . . 75--86
Omer Tripp and
Marco Pistoia and
Stephen J. Fink and
Manu Sridharan and
Omri Weisman TAJ: effective taint analysis of web
applications . . . . . . . . . . . . . . 87--97
Zachary R. Anderson and
David Gay and
Mayur Naik Lightweight annotations for controlling
sharing in concurrent data structures 98--109
Pallavi Joshi and
Chang-Seo Park and
Koushik Sen and
Mayur Naik A randomized dynamic program analysis
technique for detecting real deadlocks 110--120
Cormac Flanagan and
Stephen N. Freund FastTrack: efficient and precise dynamic
race detection . . . . . . . . . . . . . 121--133
Daniel Marino and
Madanlal Musuvathi and
Satish Narayanasamy LiteRace: effective sampling for
lightweight data-race detection . . . . 134--143
Erez Petrank and
Madanlal Musuvathi and
Bjarne Steensgaard Progress guarantee for parallel programs
via bounded lock-freedom . . . . . . . . 144--154
Aleksandar Dragojevi\'c and
Rachid Guerraoui and
Michal Kapalka Stretching transactional memory . . . . 155--165
Mojtaba Mehrara and
Jeff Hao and
Po-Chun Hsu and
Scott Mahlke Parallelizing sequential applications on
commodity hardware using a low-cost
software transactional memory . . . . . 166--176
Georgios Tournavitis and
Zheng Wang and
Björn Franke and
Michael F. P. O'Boyle Towards a holistic approach to
auto-parallelization: integrating
profile-driven parallelism detection and
machine-learning based mapping . . . . . 177--187
Pieter Hooimeijer and
Westley Weimer A decision procedure for subset
constraints over regular languages . . . 188--198
August C. Schwerdfeger and
Eric R. Van Wyk Verifiable composition of deterministic
grammars . . . . . . . . . . . . . . . . 199--210
Salvatore La Torre and
Madhusudan Parthasarathy and
Gennaro Parlato Analyzing recursive programs using a
fixed-point calculus . . . . . . . . . . 211--222
Saurabh Srivastava and
Sumit Gulwani Program verification using templates
over predicate abstraction . . . . . . . 223--234
Edward E. Aftandilian and
Samuel Z. Guyer GC assertions: using the garbage
collector to check heap properties . . . 235--244
Santosh Nagarakatte and
Jianzhou Zhao and
Milo M. K. Martin and
Steve Zdancewic SoftBound: highly compatible and
complete spatial memory safety for C . . 245--258
Yutaka Oiwa Implementation of the memory-safe full
ANSI-C compiler . . . . . . . . . . . . 259--269
Cindy Rubio-González and
Haryadi S. Gunawi and
Ben Liblit and
Remzi H. Arpaci-Dusseau and
Andrea C. Arpaci-Dusseau Error propagation analysis for file
systems . . . . . . . . . . . . . . . . 270--280
Xin Qi and
Andrew C. Myers Sharing classes between families . . . . 281--292
Tillman Rendel and
Klaus Ostermann and
Christian Hofer Typed self-representation . . . . . . . 293--303
Ming Kawaguchi and
Patrick Rondon and
Ranjit Jhala Type-based data structure verification 304--315
Jean-Baptiste Tristan and
Xavier Leroy Verified validation of lazy code motion 316--326
Sudipta Kundu and
Zachary Tatlock and
Sorin Lerner Proving optimizations correct using
parameterized program equivalence . . . 327--337
Karen Zee and
Viktor Kuncak and
Martin C. Rinard An integrated proof language for
imperative programs . . . . . . . . . . 338--351
Tristan Ravitch and
Steve Jackson and
Eric Aderhold and
Ben Liblit Automatic generation of library bindings
using static analysis . . . . . . . . . 352--362
Satish Chandra and
Stephen J. Fink and
Manu Sridharan Snugglebug: a powerful approach to
weakest preconditions . . . . . . . . . 363--374
Sumit Gulwani and
Sagar Jain and
Eric Koskinen Control-flow refinement and progress
invariants for bound analysis . . . . . 375--385
Hiroshi Inoue and
Hideaki Komatsu and
Toshio Nakatani A study of memory management for
Web-based applications on multicore
processors . . . . . . . . . . . . . . . 386--396
Gene Novark and
Emery D. Berger and
Benjamin G. Zorn Efficiently and precisely locating
memory leaks and bloat . . . . . . . . . 397--407
Ohad Shacham and
Martin Vechev and
Eran Yahav Chameleon: adaptive selection of
collections . . . . . . . . . . . . . . 408--418
Guoqing Xu and
Matthew Arnold and
Nick Mitchell and
Atanas Rountev and
Gary Sevitsky Go with the flow: profiling copies to
find runtime bloat . . . . . . . . . . . 419--430
Bratin Saha and
Xiaocheng Zhou and
Hu Chen and
Ying Gao and
Shoumeng Yan and
Mohan Rajagopalan and
Jesse Fang and
Peinan Zhang and
Ronny Ronen and
Avi Mendelson Programming model for a heterogeneous
x86 platform . . . . . . . . . . . . . . 431--440
Nathan R. Tallent and
John M. Mellor-Crummey and
Michael W. Fagan Binary analysis for measurement and
attribution of program performance . . . 441--452
Kevin J. Hoffman and
Patrick Eugster and
Suresh Jagannathan Semantics-aware trace analysis . . . . . 453--464
Andreas Gal and
Brendan Eich and
Mike Shaver and
David Anderson and
David Mandelin and
Mohammad R. Haghighat and
Blake Kaplan and
Graydon Hoare and
Boris Zbarsky and
Jason Orendorff and
Jesse Ruderman and
Edwin W. Smith and
Rick Reitmaier and
Michael Bebenita and
Mason Chang and
Michael Franz Trace-based just-in-time type
specialization for dynamic languages . . 465--478
Eric J. Stotzer and
Ernst L. Leiss Modulo scheduling without overlapped
lifetimes . . . . . . . . . . . . . . . 1--10
Paul Caspi and
Jean-Louis Colaço and
Léonard Gérard and
Marc Pouzet and
Pascal Raymond Synchronous objects with scheduling
policies: introducing safe shared memory
in Lustre . . . . . . . . . . . . . . . 11--20
Taewook Oh and
Bernhard Egger and
Hyunchul Park and
Scott Mahlke Recurrence cycle aware modulo scheduling
for coarse-grained reconfigurable
architectures . . . . . . . . . . . . . 21--30
Jia Zou and
Joshua Auerbach and
David F. Bacon and
Edward A. Lee PTIDES on flexible task graph: real-time
embedded system building from theory to
practice . . . . . . . . . . . . . . . . 31--40
Jongeun Lee and
Aviral Shrivastava A compiler optimization to reduce soft
errors in register files . . . . . . . . 41--49
Hugh Leather and
Michael O'Boyle and
Bruce Worton Raced profiles: efficient selection of
competing compiler optimizations . . . . 50--59
Xuejun Yang and
Nathan Cooprider and
John Regehr Eliminating the call stack to save RAM 60--69
Sandrine Blazy and
Benoit Robillard Live-range unsplitting for faster
optimal coalescing . . . . . . . . . . . 70--79
Abhik Sarkar and
Frank Mueller and
Harini Ramaprasad and
Sibin Mohan Push-assisted migration of real-time
tasks in multi-core processors . . . . . 80--89
Jennifer Mankin and
David Kaeli and
John Ardini Software transactional memory for
multicore embedded systems . . . . . . . 90--98
Abhishek Udupa and
R. Govindarajan and
Matthew J. Thazhuthaveetil Synergistic execution of stream programs
on multicores with accelerators . . . . 99--108
Thomas Heinz and
Reinhard Wilhelm Towards device emulation code generation 109--118
Stephen Roderick Hines and
Yuval Peress and
Peter Gavin and
David Whalley and
Gary Tyson Guaranteeing instruction fetch behavior
with a Lookahead Instruction Fetch
Engine (LIFE) . . . . . . . . . . . . . 119--128
Paul E. McKechnie and
Michaela Blott and
Wim A. Vanderbauwhede Debugging FPGA-based packet processing
systems through transaction-level
communication-centric monitoring . . . . 129--136
Giovani Gracioli and
Sebastian Fischmeister Tracing interrupts in embedded software 137--146
Ryan W. Moore and
José A. Baiocchi and
Bruce R. Childers and
Jack W. Davidson and
Jason D. Hiser Addressing the challenges of DBT for the
ARM architecture . . . . . . . . . . . . 147--156
Colin J. Fidge and
Diane Corney Integrating hardware and software
information flow analyses . . . . . . . 157--166
Charles André and
Frédéric Mallet Specification and verification of time
requirements with CCSL and Esterel . . . 167--176
Avik Chaudhuri Language-based security on Android
(abstract only) . . . . . . . . . . . . 4--4
Brian W. DeVries and
Gopal Gupta and
Kevin W. Hamlen and
Scott Moore and
Meera Sridhar ActionScript bytecode verification with
co-logic programming (abstract only) . . 4--4
Limin Jia and
Steve Zdancewic Encoding information flow in AURA
(abstract only) . . . . . . . . . . . . 4--4
Daniel Wasserrab and
Denis Lohner and
Gregor Snelting On PDG-based noninterference and its
modular proof (abstract only) . . . . . 4--5
Aslan Askarov and
Andrei Sabelfeld Catch me if you can: permissive yet
secure error handling (abstract only) 5--5
Musard Balliu and
Isabella Mastroeni A weakest precondition approach to
active attacks analysis (abstract only) 5--5
James Newsome and
Stephen McCamant and
Dawn Song Measuring channel capacity to
distinguish undue influence (abstract
only) . . . . . . . . . . . . . . . . . 5--5
Thomas H. Austin and
Cormac Flanagan Efficient purely-dynamic information
flow analysis (abstract only) . . . . . 6--6
Arnar Birgisson and
Úlfar Erlingsson An implementation and semantics for
transactional memory introspection in
Haskell (abstract only) . . . . . . . . 6--6
Niklas Broberg and
David Sands Flow-sensitive semantics for dynamic
information flow policies (abstract
only) . . . . . . . . . . . . . . . . . 6--6
Avraham Shinnar and
Marco Pistoia and
Anindya Banerjee A language for information flow: dynamic
tracking in multiple interdependent
dimensions (abstract only) . . . . . . . 6--6
Limin Jia and
Steve Zdancewic Encoding information flow in AURA . . . 7--19
Thomas H. Austin and
Cormac Flanagan Efficient purely-dynamic information
flow analysis . . . . . . . . . . . . . 20--31
Guy L. Steele, Jr. Organizing functional code for parallel
execution or, foldl and foldr considered
slightly harmful . . . . . . . . . . . . 1--2
Ralf Hinze Functional pearl: la tour d'Hano\"\i . . 3--10
Sebastian Fischer and
Oleg Kiselyov and
Chung-chieh Shan Purely functional lazy non-deterministic
programming . . . . . . . . . . . . . . 11--22
Neil Sculthorpe and
Henrik Nilsson Safe functional reactive programming
through dependent types . . . . . . . . 23--34
Hai Liu and
Eric Cheng and
Paul Hudak Causal commutative arrows and their
optimization . . . . . . . . . . . . . . 35--46
Matthias Felleisen and
Robert Bruce Findler and
Matthew Flatt and
Shriram Krishnamurthi A functional I/O system or, fun for
freshman kids . . . . . . . . . . . . . 47--58
Ryan R. Newton and
Teresa Ko Experience report: embedded, parallel
computer-vision with a functional DSL 59--64
Simon Marlow and
Simon Peyton Jones and
Satnam Singh Runtime support for multicore Haskell 65--78
Adam Chlipala and
Gregory Malecha and
Greg Morrisett and
Avraham Shinnar and
Ryan Wisnesky Effective interactive proofs for
higher-order imperative programs . . . . 79--90
Gerwin Klein and
Philip Derrin and
Kevin Elphinstone Experience report: seL4: formally
verifying a high-performance microkernel 91--96
Nick Benton and
Chung-Kil Hur Biorthogonality, step-indexing and
compiler correctness . . . . . . . . . . 97--108
Matthew Flatt and
Eli Barzilay and
Robert Bruce Findler Scribble: closing the book on ad hoc
documentation tools . . . . . . . . . . 109--120
Benjamin C. Pierce Lambda, the ultimate TA: using a proof
assistant to teach programming language
foundations . . . . . . . . . . . . . . 121--122
Daniel R. Licata and
Robert Harper A universe of binding and computation 123--134
Georg Neis and
Derek Dreyer and
Andreas Rossberg Non-parametric parametricity . . . . . . 135--148
Koen Claessen and
Michal Palka and
Nicholas Smallbone and
John Hughes and
Hans Svensson and
Thomas Arts and
Ulf Wiger Finding race conditions in Erlang with
QuickCheck and PULSE . . . . . . . . . . 149--160
Lukasz Ziarek and
KC Sivaramakrishnan and
Suresh Jagannathan Partial memoization of concurrency and
communication . . . . . . . . . . . . . 161--172
Janis Voigtländer Free theorems involving type constructor
classes: functional pearl . . . . . . . 173--184
Curt J. Sampson Experience report: Haskell in the `real
world': writing a commercial application
in a lazy functional language . . . . . 185--190
Conal M. Elliott Beautiful differentiation . . . . . . . 191--202
Thomas Gazagnaire and
Vincent Hanquez OXenstored: an efficient hierarchical
and transactional database using
functional programming with reference
cell comparisons . . . . . . . . . . . . 203--214
Bruno Pagano and
Olivier Andrieu and
Thomas Moniot and
Benjamin Canou and
Emmanuel Chailloux and
Philippe Wang and
Pascal Manoury and
Jean-Louis Colaço Experience report: using objective caml
to develop safety-critical embedded
tools in a certification framework . . . 215--220
Pierre Genev\`es and
Nabil Laya\"\ida and
Vincent Quint Identifying query incompatibilities with
evolving XML schemas . . . . . . . . . . 221--230
Dan P. Piponi Commutative monads, diagrams and knots 231--232
Alexey Rodriguez Yakushev and
Stefan Holdermans and
Andres Löh and
Johan Jeuring Generic programming with fixed points
for mutually recursive datatypes . . . . 233--244
Marcos Viera and
S. Doaitse Swierstra and
Wouter Swierstra Attribute grammars fly first-class: how
to do aspect oriented programming in
Haskell . . . . . . . . . . . . . . . . 245--256
John Reppy and
Claudio V. Russo and
Yingqi Xiao Parallel concurrent ML . . . . . . . . . 257--268
Avik Chaudhuri A concurrent ML library in concurrent
Haskell . . . . . . . . . . . . . . . . 269--280
Pascal Cuoq and
Julien Signoles and
Patrick Baudin and
Richard Bonichon and
Géraud Canet and
Lo\"\ic Correnson and
Benjamin Monate and
Virgile Prevosto and
Armand Puccetti Experience report: OCaml for an
industrial-strength static analysis
framework . . . . . . . . . . . . . . . 281--286
Jan Midtgaard and
Thomas P. Jensen Control-flow analysis of function calls
and returns by abstract interpretation 287--298
Jay A. McCarthy Automatically RESTful web applications:
marking modular serializable
continuations . . . . . . . . . . . . . 299--310
Vincent Balat and
Jérôme Vouillon and
Boris Yakobowski Experience report: ocsigen, a web
programming framework . . . . . . . . . 311--316
Tiark Rompf and
Ingo Maier and
Martin Odersky Implementing first-class polymorphic
delimited continuations by a
type-directed selective CPS-transform 317--328
Nikhil Swamy and
Michael Hicks and
Gavin M. Bierman A theory of typed coercions and its
applications . . . . . . . . . . . . . . 329--340
Tom Schrijvers and
Simon Peyton Jones and
Martin Sulzmann and
Dimitrios Vytiniotis Complete and decidable type inference
for GADTs . . . . . . . . . . . . . . . 341--352
Leo A. Meyerovich and
Arjun Guha and
Jacob Baskin and
Gregory H. Cooper and
Michael Greenberg and
Aleks Bromfield and
Shriram Krishnamurthi Flapjax: a programming language for Ajax
applications . . . . . . . . . . . . . . 1--20
Donna Malayeri and
Jonathan Aldrich CZ: multiple inheritance without
diamonds . . . . . . . . . . . . . . . . 21--40
Roland Ducournau and
Floréal Morandat and
Jean Privat Empirical assessment of object-oriented
implementations with multiple
inheritance and static typing . . . . . 41--60
Roberto Lublinerman and
Swarat Chaudhuri and
Pavol Cerny Parallel programming with object
assemblies . . . . . . . . . . . . . . . 61--80
Emery D. Berger and
Ting Yang and
Tongping Liu and
Gene Novark Grace: safe multithreaded programming
for C/C++ . . . . . . . . . . . . . . . 81--96
Robert L. Bocchino, Jr. and
Vikram S. Adve and
Danny Dig and
Sarita V. Adve and
Stephen Heumann and
Rakesh Komuravelli and
Jeffrey Overbey and
Patrick Simmons and
Hyojin Sung and
Mohsen Vakilian A type and effect system for
deterministic parallel Java . . . . . . 97--116
Bard Bloom and
John Field and
Nathaniel Nystrom and
Johan Östlund and
Gregor Richards and
Rok Strni\vsa and
Jan Vitek and
Tobias Wrigstad Thorn: robust, concurrent, extensible
scripting on the JVM . . . . . . . . . . 117--136
Hiroshi Inoue and
Toshio Nakatani How a Java VM can get more from a
hardware performance monitor . . . . . . 137--154
Jungwoo Ha and
Matthew Arnold and
Stephen M. Blackburn and
Kathryn S. McKinley A concurrent dynamic analysis framework
for multicore hardware . . . . . . . . . 155--174
Todd Mytkowicz and
Devin Coughlin and
Amer Diwan Inferred call path profiling . . . . . . 175--190
Philippe Charles and
Robert M. Fuhrer and
Stanley M. Sutton, Jr. and
Evelyn Duesterwald and
Jurgen Vinju Accelerating the creation of customized,
language-Specific IDEs in Eclipse . . . 191--206
Byeongcheol Lee and
Martin Hirzel and
Robert Grimm and
Kathryn S. McKinley Debug all your code: portable
mixed-environment debugging . . . . . . 207--226
Daan Leijen and
Wolfram Schulte and
Sebastian Burckhardt The design of a task parallel library 227--242
Martin Bravenboer and
Yannis Smaragdakis Strictly declarative specification of
sophisticated points-to analyses . . . . 243--262
Chieri Saito and
Atsushi Igarashi Self type constructors . . . . . . . . . 263--282
Michael Furr and
Jong-hoon (David) An and
Jeffrey S. Foster Profile-guided static typing for dynamic
scripting languages . . . . . . . . . . 283--300
Myoungkyu Song and
Eli Tilevich Enhancing source-level programming tools
with an awareness of transparent program
transformations . . . . . . . . . . . . 301--320
Marwan Abi-Antoun and
Jonathan Aldrich Static extraction and conformance
analysis of hierarchical runtime
architectural structure using
annotations . . . . . . . . . . . . . . 321--340
Mangala Gowri Nanda and
Senthil Mani and
Vibha Singhal Sinha and
Saurabh Sinha Demystifying model transformations: an
approach based on automated rule
inference . . . . . . . . . . . . . . . 341--360
Yi Zhao and
Jin Shi and
Kai Zheng and
Haichuan Wang and
Haibo Lin and
Ling Shao Allocation wall: a limiting factor of
Java applications on emerging multi-core
platforms . . . . . . . . . . . . . . . 361--376
Takeshi Ogasawara NUMA-aware memory manager with
dominant-thread-based copying GC . . . . 377--390
Frédéric Pluquet and
Stefan Langerman and
Roel Wuyts Executing code in the past: efficient
in-memory object graph versioning . . . 391--408
Daniel von Dincklage and
Amer Diwan Optimizing programs with intended
semantics . . . . . . . . . . . . . . . 409--424
Dan Tsafrir and
Robert W. Wisniewski and
David F. Bacon and
Bjarne Stroustrup Minimizing dependencies within generic
classes for faster and smaller programs 425--444
Lennart C. L. Kats and
Maartje de Jonge and
Emma Nilsson-Nyman and
Eelco Visser Providing rapid feedback in generated
modular language environments: adding
error recovery to scannerless
generalized-LR parsing . . . . . . . . . 445--464
Dirk Riehle Design pattern density defined . . . . . 469--480
Thomas Mullen Writing code for other people: cognitive
psychology and the fundamentals of good
software design principles . . . . . . . 481--492
Jeffrey L. Overbey and
Ralph E. Johnson Regrowing a language: refactoring tools
allow programming languages to evolve 493--502
Roman Knöll and
Mira Mezini $\pi$: a pattern language . . . . . . . 503--522
Mark Mahoney Software evolution and the moving
picture metaphor . . . . . . . . . . . . 525--528
Jenny Quillien and
Pam Rostal and
Dave West Agile anthropology and Alexander's
architecture: an essay in three voices 529--546
Elisa Baniassad and
Clayton Myers An exploration of program as language 547--556
William R. Cook On understanding data abstraction,
revisited . . . . . . . . . . . . . . . 557--572
Jim Allen and
Zena Ariola and
Pierre-Louis Curien and
Matthew Fluet and
Jeff Foster and
Dan Grossman and
Robert Harper and
Hugo Herbelin and
Yannis Smaragdakis and
David Walker and
Steve Zdancewic An overview of the Oregon programming
languages summer school . . . . . . . . 1--3
Matthew Danish and
Hongwei Xi Operating system development with ATS:
work in progress: (abstract only) . . . 6--6
Stefan Monnier and
David Haguenauer Singleton types here, singleton types
there, singleton types everywhere:
(abstract only) . . . . . . . . . . . . 6--6
Stephanie Balzer and
Thomas R. Gross Modular reasoning about invariants over
shared state with interposed data
members: (abstract only) . . . . . . . . 6--7
Jan Christiansen and
Daniel Seidel and
Janis Voigtländer Free theorems for functional logic
programs: (abstract only) . . . . . . . 7--7
Aaron Stump and
Evan Austin Resource typing in Guru: (abstract only) 7--7
Stephanie Weirich and
Chris Casinghino Arity-generic datatype-generic
programming: (abstract only) . . . . . . 7--7
Tomas Kalibera and
Pavel Parizek and
Ghaith Haddad and
Gary T. Leavens and
Jan Vitek Challenge benchmarks for verification of
real-time programs: (abstract only) . . 7--8
Jan Vitek Of scripts and programs: tall tales,
urban legends, and future prospects . . 1--2
Éric Tanter Beyond static and dynamic scope . . . . 3--14
Eyvind W. Axelsen and
Stein Krogdahl Groovy package templates: supporting
reuse and runtime adaption of class
hierarchies . . . . . . . . . . . . . . 15--26
T. Stephen Strickland and
Matthias Felleisen Contracts for first-class modules . . . 27--38
Jonathan Riehl Language embedding and optimization in
Mython . . . . . . . . . . . . . . . . . 39--48
Yit Phang Khoo and
Michael Hicks and
Jeffrey S. Foster and
Vibha Sazawal Directing JavaScript with arrows . . . . 49--58
Pascal Costanza and
Charlotte Herzeel and
Theo D'Hondt Context-oriented software transactional
memory in Common Lisp . . . . . . . . . 59--68
Frédéric Pluquet and
Antoine Marot and
Roel Wuyts Fast type reconstruction for dynamically
typed programming languages . . . . . . 69--78
Alexander Yermolovich and
Christian Wimmer and
Michael Franz Optimization of dynamic languages using
hierarchical layering of virtual
machines . . . . . . . . . . . . . . . . 79--88
Michael Furr and
Jong-hoon (David) An and
Jeffrey S. Foster and
Michael Hicks The Ruby intermediate language . . . . . 89--98
David Ungar and
Sam S. Adams Hosting an object heap on manycore
hardware: an exploration . . . . . . . . 99--110