PPPJ 2009: 7th International Conference on the Principles and Practice of Programming in Java
Welcome Dates Program Venue Organizers Poster Register

PPPJ 2009 Sponsors:

In Cooperation With:

Thursday August 27, 2009

Friday August 28, 2009

Keynote Address:

This year's keynote address was scheduled to be delivered by Dr. James Gosling, Vice President and Sun Fellow with Sun Microsystems Inc. Unfortunately Dr. Gosling requires surgery for an urgent medical condition, and as such, will be unable to deliver the address as planned. Our alternative speaker will be Ondrej Lhotak from the University of Waterloo. His address is titled "The State of Reference Analysis".

Paper Session: Applications 1

     Solve & Evaluate with Informa: A Java-based Classroom Response System for Teaching Java
     Matthias Hauswirth and Andrea Adamoli

     Actor frameworks for the JVM platform: A Comparative Analysis
     Rajesh Karmani, Amin Shali and Gul Agha

     Development of a Java-based Unified and Flexible Natural Language Discourse System
     Philip Hanna, Ian O'Neill, Darryl Stewart and Behrang Qasemizadeh

Paper Session: Applications 2

     Java for High Performance Computing: Assessment of Current Research and Practice
     Guillermo Taboada, Juan Tourino and Doallo Ramon

     A Framework for Constructing Peer-to-Peer Overlay Networks in Java
     Rui Shen, Ji Wang, Shengdong Zhang, Siqi Shen and Pei Fan

     Unit Test Support for Java via Reflection and Annotations
     Viera K. Proulx and Weston Jossey

Paper Session: Language

     Three Approaches to Object Evolution
     Tal Cohen and Joseph (Yossi) Gil

     Safer Typing of Complex API Usage through Java Generics
     William Harrison, David Lievens and Fabio Simeoni

     Parsing Fortress Syntax
     Sukyoung Ryu

     A Discipline of Tree Processing
     Axel T. Schreiner and James E. Heliotis

Paper Session: Parallelization

     Automatic Parallelization for Graphics Processing Units
     Alan Leung, Ondrej Lhotak and Ghulam Lashari

     The Use of Hardware Transactional Memory for the Trace-Based Parallelization of Recursive Java Programs
     Borys Bradel and Tarek Abdelrahman

     Parallelizing Calling Context Profiling in Virtual Machines on Multicores
     Walter Binder, Danilo Ansaloni, Alex Villazon and Philippe Moret

Paper Session: Tool Demonstrations

     Analyzing Performance and Dynamic Behavior of Embedded Java Software with Calling-Context Cross-Profiling
     Philippe Moret, Walter Binder, Martin Schoeberl, Alex Villazon and Danilo Ansaloni

     MAJOR: Rapid Tool Development with Aspect-Oriented Programming
     Alex Villazon, Walter Binder, Philippe Moret and Danilo Ansaloni

     ConcJUnit: Unit Testing for Concurrent Programs
     Mathias Ricken and Robert Cartwright

Paper Session: Virtual Machines 1

     SlimVM: A Small Footprint Java Virtual Machine for Connected Embedded Systems
     Christoph Kerschbaumer, Gregor Wagner, Christian Wimmer, Andreas Gal, Michael Franz and Christian Steger

     Lazy Continuations for Java Virtual Machines
     Lukas Stadler, Christian Wimmer, Thomas Wurthinger, Hanspeter Mossenbock and John Rose

     Stack Allocation of Objects in the Cacao Virtual Machine
     Peter Molnar, Andreas Krall and Florian Brandner

Paper Session: Virtual Machines 2

     Tracking Performance Across Software Revisions
     Nagy Mostafa and Chandra Krintz

     Phase Detection using Trace Compilation
     Christian Wimmer, Marcelo Cintra, Michael Bebenita, Mason Chang, Andreas Gal and Michael Franz

     Virtual Reuse Distance Analysis for SPECjvm2008 Data Locality
     Xiaoming Gu, Xiao-Feng Li, Buqi Cheng and Eric Huang

Tutorial A: Alice 3 and Java for CS1 & AP CS

Wanda Dann, Carnegie Mellon University
Stephen Cooper, Saint Joseph's University
Don Slater, Carnegie Mellon University

Tutorial A has been cancelled due to low enrolment.

Tutorial B: Preventing Bugs with Pluggable Type-Checking

Michael D. Ernst, University of Washington

The Java type system helps programmers to detect and prevent errors. However, Java's built-in type system does not detect and prevent enough errors. It cannot express important properties such as: a reference is non-null, a data structure should not be modified, or a string has been properly sanitized.

Java's type system can be extended to enforce such properties statically, preventing whole classes of errors. However, such type system extensions have not been practical in the past, in part because their implementations have been inexpressive, unscalable, or incompatible with existing languages or tools.

More recently, pluggable types (that operate as an optional plug-in to the compiler) have become practical for Java. This benefits two constituencies:

  • Programmers can detect and prevent errors in their code.
  • Type system designers can easily evaluate new type systems in the context of an industrial programming language.

The line between these constituencies is porous: a developer may create a simple type system to enforce an application-specific property.

This tutorial will explain how to both use and create pluggable type systems. Afterward, you will be ready to use pluggable types with confidence and to create simple type-checkers of your own, and you will know where to look for more information.

The hands-on activities will use the Checker Framework, which provides expressive, concise declarative and procedural mechanisms for creating pluggable type checkers for Java. However, the ideas extend to other frameworks and languages. The Checker Framework is the basis of many practical checkers that have found hundreds of important errors in millions of lines of code. The Checker Framework is being used by researchers worldwide, and it has yielded new insight into research type systems. It is usable with any version of the Java language, but pluggable types are so important that Java 7 will contain special syntax (designed by the presenter of this tutorial) to support type qualifiers.

The tutorial will cover both theory and practice, and is applicable both to researchers and also to practitioners who wish to verify domain-specific properties in their software. For example, you will learn how type system designers can build scalable, robust, and easily deployable type-checkers. During the tutorial, you will build your own type-checker. After the tutorial, you will be prepared to use, create, or customize pluggable type-checkers.

Attendees are suggested to bring laptop computers, though it is also possible to look on with another attendee.

About the Presenters:

Michael Ernst is Associate Professor at the University of Washington, and is the specification lead for the Type Annotations language extension (``JSR 308'') that is part of Java 7. He is the first non-Sun-employee to be the specification lead for a Java language change. He is also a member of the expert group for JSR 305 and is the author of many tools for improving programmer productivity. For more information, see http://www.cs.washington.edu/homes/mernst/.