Onward! Papers 1: Decoupling

Tue 10:30-12:00 pm - Rose Ballroom B
Registration-Based Language Abstractions
Samuel Davis, University of British Columbia, Canada
Gregor Kiczales, University of British Columbia, Canada

Programming language innovation has been hindered by the difficulty of making changes to existing languages. A key source of difficulty is the tyrannical nature of existing approaches to realizing languages—adding a new language construct means that any tool, document or programmer that works with the language must be prepared to deal with that construct.

A registration-based approach makes it possible to define language constructs that are not tyrannical. They are instead transient—the program appears to be written using the constructs only so long as a given programmer wants to see it that way. This approach may have the potential to greatly facilitate programming language innovation.

Pinocchio: Bringing Reflection to Life with First-Class Interpreters
Toon Verwaest, SCG University of Berne, Switzerland, Switzerland
Camillo Bruni, SCG University of Berne, Switzerland, Switzerland
David Gurtner, SCG University of Berne, Switzerland, Switzerland
Adrian Lienhard, SCG University of Berne, Switzerland, Switzerland
Oscar Nierstrasz, SCG University of Berne, Switzerland, Switzerland

To support development tools like debuggers, runtime systems need to provide a meta-programming interface to alter their semantics and access internal data. Reflective capabilities are typically fixed by the Virtual Machine (VM). Unanticipated reflective features must either be simulated by complex program transformations, or they require the development of a specially tailored VM. We propose a novel approach to behavioral reflection that eliminates the barrier between applications and the VM by manipulating an explicit tower of first-class interpreters. Pinocchio is a proof-of-concept implementation of our approach which enables radical changes to the interpretation of programs by explicitly instantiating subclasses of the base interpreter. We illustrate the design of Pinocchio through non-trivial examples that extend runtime semantics to support debugging, parallel debugging, and back-in-time object-flow debugging. Although performance is not yet addressed, we also discuss numerous opportunities for optimization, which we believe will lead to a practical approach to behavioral reflection.

Keywords: Smalltalk, Behavioral Reflection, Metacircularity, Virtual Machines, Debugging, Object-Flow Analysis

Concurrency by Modularity: Design Patterns, a Case in Point
Hridesh Rajan, Iowa State University, United States
Steven Kautz, Iowa State University, United States
Wayne Rowcliffe, Iowa State University, United States

General purpose object-oriented programs typically aren't embarrassingly parallel. For these applications, finding enough concurrency remains a challenge in program design. To address this challenge, in the Panini project we are looking at reconciling concurrent program design goals with modular program design goals. The main idea is that if programmers improve the modularity of their programs they should get concurrency for free. In this work we describe one of our directions to reconcile these two goals by enhancing Gang-of-Four (GOF) object-oriented design patterns. GOF patterns are commonly used to improve the modularity of object-oriented software. These patterns describe strategies to decouple components in design space and specify how these components should interact. Our hypothesis is that if these patterns are enhanced to also decouple components in execution space applying them will concomitantly improve the design and potentially available concurrency in software systems. To evaluate our hypothesis we have studied all 23 GOF patterns. For 18 patterns out of 23, our hypothesis has held true. Another interesting preliminary result reported here is that for 17 out of these 18 studied patterns, concurrency and synchronization concerns were completely encapsulated in our concurrent design pattern framework.


2009 Highlights

Barbara Liskov

In a reprise of her ACM Turing Award lecture, Barbara Liskov discusses the invention of abstract data types, the CLU programming language, clusters, polymorphism, exception handling, iterators, implementation inheritance, type hierarchies, the Liskov Substitution Principle, polymorphism, and future challenges such as new abstractions, parallelism, and the Internet.

Watch the video on InfoQ.

More Highlights