22Nd European Conference on Object-Oriented Programming

22nd European Conference On Object-Oriented Programming

CONFERENCE GUIDE

Paphos, Cyprus. July 7 - 11, 2008 http://2008.ecoop.org

Because of copyright restrictions, we cannot make copies of papers available at the ECOOP’08 conference. However, this handbook provides you with the titles and abstracts of all papers so that you can make informed decisions as to which sessions you will attend. The handbook also contains vital information on the conference timetable and venue. The main venue for the ECOOP’08 conference is the Coral Beach Resort, in the city of Paphos. At the end of this handbook you will also find some general information, including what to do in the case of a mishap (e.g. personal accident, laptop repairs, damaged clothing). About This Guide We hope that you find this handbook useful, and we wish you a pleasant stay and safe trip home.

Table of Contents Welcome Message························································· 1 AITO Dahl-Nygaard Prizes············································ 2 Workshops ··································································· 4 Technical Paper Abstracts············································· 6 Posters ········································································ 20 Demonstrations ·························································· 23 Dynamic Languages Symposium 2008 ························ 31 Social Events······························································· 33 Conference Site Information ······································ 34 General Information··················································· 37 Committees ································································ 39 Student Volunteers····················································· 41 Conference Program··················································· 42 SEIT Lab @ University of Cyprus ······························· 47

iii

Dear Participant. Welcome to ECOOP 2008 in Paphos! ECOOP 2008‘s Organizing Committee is pleased to welcome you to the lovely city of Paphos. Since it was first held in Paris in 1987, ECOOP travels for the first time to the sunny island of Cyprus. As it is traditional for the ECOOP event, this year’s “ECOOP week” features a number of workshops, tutorials, and other events, all of them complementing the main technical program. From the beginning, ECOOP has been the premier forum for discussing and advancing a broad range of topics woven together by the common thread of object technology. It offers a well-integrated collage of events, including outstanding invited speakers, carefully refereed technical papers, topic-focused workshops and late-breaking demonstrations. The main reason for ECOOP‘s ongoing success is its excellent technical program, put together each year from a large number of high-quality sub- Welcome Message Message Welcome missions. This year‘s Program Chair is Jan Vitek, with whom it has been a great pleasure to cooperate. We are delighted to announce three outstanding keynote talks. The conference keynote will be given by Rachid Guerraoui. The other keynote talks will be given by Akinori Yonezawa and Wolfgang De Meuter, the 2008 winners of the AITO Dahl-Nygaard Awards. These prizes, named after Ole-Johan Dahl and Kristen Nygaard in recognition of their pioneer- ing work on object-oriented programming, are being awarded for the fourth time this year. We wish to thank all those who are organizing workshops, giving tutorials, presenting demonstrations or offering posters for their significant efforts, all of which contribute to the richness of the ECOOP tapestry. ECOOP 2008 is being organized by the University of Cyprus. It is being held under the auspices of AITO, the Association Internationale pour les Technologies Objets, in cooperation with ACM, SIGPLAN and SIG- SOFT. The conference would not have been possible without the financial support of sponsors. Special thanks go to our Silver Sponsors Google, IBM and Microsoft Research. Enjoy ECOOP 2008! Enjoy your stay in Paphos! George A. Papadopoulos on behalf of the Organizing Committee

SENIOR PRIZE Aito Dahl-Nygaard Prizes Akinori Yonezawa systematically developed theories and practical implementations for concurrent object-oriented languages, from the early incarnation of Actors in the late 70’s to the ABCL language series in the early 90’s, eventually leading to the seminal book "Object-Oriented Concurrent Pro- gramming", published with Mario Tokoro in 1987. His con- tributions to concurrent object-oriented languages range from theoretical foundations and massively parallel and efficient implementations of programs, to incorporating computational reflection in concurrent language designs – long be- fore reflection was considered mainstream in object-oriented languages. In his work on theoretical foundations, he tackled the problem of formalizing the notion of concurrent objects in various ways, defining succinct operational semantics for concurrent objects using higher-order calculi and other forms of logical systems, such as linear logic, to provide the much needed rigor to the discipline of concurrent object programming. On the implementation side, in the early 90’s he lead the team that implemented several variants of ABCL on supercomputers such as the Fujitsu AP1000 that embodied 512 nodes which was by far one of the largest and fastest parallel supercomputers in those days. He was also the first person to suggest a model of computational reflection for concurrent objects, and continuously extended the work so that reflective capabilities became both functionally powerful and effi- ciently implementable in today’s object oriented programming languages and systems. With JavaGo, he has continued to contribute in the area of object mobility and concurrency.

JUNIOR PRIZE Wolfgang De Meuter has shown promising potential as a young researcher by proposing innovative ideas and by proving that these are conceptually sound and realistically implementable. He has focused his research and teaching on several different concepts such as formal semantics of prototype-based languages, innovation in AOP (e.g., monads for AOP and jumping aspects giving rise to cflow), and more recently programming languages for ambient systems. In his Ph.D. dissertation on "Move Considered Harmful: A Lan- guage Design Approach to Mobility and Distribution for Open Networks", he proposes a new conceptual model for strong code mobility in prototype-based object-oriented systems. The Ph.D. was the precursor of the AmbientTalk language that was recently developed by Wolfgang and his students. The language targets ambient-oriented environments where failure is the rule rather than the exception. It supports new service discovery techniques, techniques to deal

Aito Dahl-Nygaard Prizes Dahl-Nygaard Aito with knowledge that is distributed over volatile connections, and advanced remote object referencing techniques, as well as replication and reversible computations. Like Dahl and Nygaard, Wolfgang challenges students to look at new things, be it virtual machine technology or context-aware programming, with a disciplined questioning eye. And he is not afraid to challenge old established concepts as witnessed by the title of his Ph.D. He encourages the development of sound concepts backed with the practice of prototype implementations in preparing a new generation of researchers. He also continues to work toward putting dynamic languages back on the scientific agenda.

MONDAY, JULY 7TH Workshops WS1 International Workshop on Aliasing, Confinement and Ownership in object-oriented programming (IWACO) Room: Akamas A

WS2 International Workshop on Multiparadigm Program- ming with Object-Oriented Languages (MPOOL) Room: Akamas B

WS3 Reflection, AOP and Meta-Data for Software Evolu- tion (RAM-SE) Room: Akamas C

WS4 Fifth European Lisp Workshop (ELW) Room: Aphrodite A

WS5 3rd Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS) Room: Aphrodite B

TUESDAY, JULY 8TH WS6 Tenth Workshop on Formal Techniques for Java-like Programs (FTfJP) Room: Akamas B

WS7 International Workshop on Advanced Software De- velopment Tools and Techniques (WASDeTT) Workshops Workshops Room: Akamas C

WS8 Parallel/High-Performance Object-Oriented Scien- tific Computing workshop (POOSC) Room: Aphrodite A

WS9 Aspects, Dependencies, and Interactions Workshop (ADI) Room: Aphrodite B

WS10 2nd International Workshop on Equation-Based Ob- ject-Oriented Languages and Tools (EOOLT) Room: Leda

WS11 Twelfth Workshop on Quantitative Approaches on Object Oriented Software Engineering (QAOOSE 2008) Room: Athena WS12 PhD Workshop Room: Zeus

WEDNESDAY, JULY 9TH Technical papers 8:00 - 9:00 Registration 9:00 - 10:00 Invited Talk The Return of Transactions Rachid Guerraoui - EPFL, Switzerland Major chip manufacturers have recently shifted their focus from speeding individual processors to multiplying them on the same chip and shipping multicore architectures. Boosting the performance of programs will thus necessarily go through parallelizing them. This is not trivial and the aver- age programmer will badly need abstractions for synchronizing concurrent accesses to shared memory objects. The transaction abstraction looks promising for this purpose and there is a lot of interest around its use in modern parallel programming. This talk will investigate whether the "return" of the old transaction idea brings any interesting research ques- tion, especially for the programming language community. 10:00—11:30 A Model for Java with Wildcards Nicholas Cameron, Sophia Drossopoulou - Imperial College London, UK Erik Ernst - University of Aarhus, Denmark Wildcards are a complex and subtle part of the Java type system, present since version 5.0. Although there have been various formalisations and partial type soundness results concerning wildcards, to the best of our knowledge, no system that includes all the key aspects of Java wildcards has been proven type sound. This paper establishes that Java wildcards are type sound. We describe a new formal model based on explicit exis- tential types whose pack and unpack operations are handled implicitly, and prove it type sound. Moreover, we specify a translation from a subset of Java to our formal model, and discuss how several interesting aspects of the Java type system are handled. On Validity of Program Transformations in the Java Memory Model Jaroslav Ševčík, David Aspinall - University of Edinburgh, Laboratory for Foundations of Computer Science, United Kingdom We analyse the validity of several common program transformations in multi-threaded Java, as defined by the Memory Model section of the Java Language Specification. The main design goal of the Java Memory Model

(JMM) was to allow as many optimisations as possible. However, we find that commonly used optimisations, such as common subexpression elimination, can introduce new behaviours and so are invalid for Java. In this paper, we describe several kinds of transformations and explain the problems with a number of counterexamples. More positively, we also examine some valid transformations, and prove their validity. Our study contributes to the understanding of the JMM, and has the practical impact of revealing some cases where the Sun Hotspot JVM does not com- ply with the Java Memory Model. Safe Cross-language Inheritance Kathryn E Gray - University of Cambridge, UK Inheritance is a standard means for reuse and for interfacing with external libraries. In a multi-language software product, extending a class written in a statically-typed language with a dynamically-typed class can re-

Technical papers papers Technical quire a significant number of manual indirections and other error-prone complications. Building on our previous interoperability work, we introduce a technique that allows safe, easy inheritance across languages. We demonstrate our technique for cross-language inheritance with a statically-typed object calculus and a dynamically-typed object calculus, where a statically-typed class can extend a dynamically-typed one and vice versa. We provide a proof sketch of soundness, as well as a guarantee that dynamic type errors do not arise due to statically-typed expressions. 12:00 - 13:30 Liquid Metal: Object-Oriented Programming Across the Hardware/ Software Boundary Shan Shan Huang - Georgia Institute of Technology, USA Amir Hormati - University of Michigan, USA David Bacon, Rodric Rabbah - IBM Research, USA The paradigm shift in processor design from monolithic processors to multicore has renewed interest in programming models that facilitate parallelism. While multicores are here today, the future is likely to wit- ness architectures that use reconfigurable fabrics (FPGAs) as coproces- sors. FPGAs provide an unmatched ability to tailor their circuitry per application, leading to better performance at lower power. Unfortu- nately, the skills required to program FPGAs are beyond the expertise of skilled software programmers. This paper shows how to bridge the gap between programming software vs. hardware. We introduce Lime, a new Object-Oriented language that can be compiled for the JVM or into a

synthesizable hardware description language. Lime extends Java with fea- Technical papers tures that provide a way to carry OO concepts into efficient hardware. We detail an end-to-end system from the language down to hardware synthesis and demonstrate a Lime program running on both a conventional processor and in an FPGA. Kilim: Isolation-Typed Actors for Java Sriram Srinivasan, Alan Mycroft - University of Cambridge Computer Laboratory, UK This paper describes Kilim, a framework that employs a combination of techniques to help create robust, massively concurrent systems in mainstream languages such as Java: (i ) ultra-lightweight, cooperatively- scheduled threads (actors ), (ii ) a message-passing framework (no shared memory, no locks) and (iii ) isolation-aware messaging. Isolation is achieved by controlling the shape and ownership of mutable messages – they must not have internal aliases and can only be owned by a single actor at a time. We demonstrate a static analysis built around isolation type qualifiers to enforce these constraints. Kilim comfortably scales to handle hundreds of thousands of actors and messages on modest hardware. It is fast as well – task-switching is 1000x faster than Java threads and 60x faster than other lightweight tasking frameworks, and message-passing is 3x faster than Erlang (currently the gold standard for concurrency-oriented programming). A Uniform Transactional Execution Environment for Java Lukasz Ziarek, Suresh Jagannathan - Purdue University, USA Adam Welc, Ali-Reza Adl-Tabatabai, Vijay S Menon, Tatiana Shpeisman - Intel Corporation, USA Transactional memory (TM) has recently emerged as an effective tool for extracting fine-grain parallelism from declarative critical sections. In order to make STM systems practical, significant effort has been made to inte- grate transactions into existing programming languages. Unfortunately, existing approaches fail to provide a simple implementation that permits lock-based and transaction-based abstractions to coexist seamlessly. Be- cause of the fundamental semantic differences between locks and transactions, legacy applications or libraries written using locks can not be trans- parently used within atomic regions. To address these shortcomings, we implement a uniform transactional execution environment for Java programs in which transactions can be integrated with more traditional concurrency control constructs. Programmers can run arbitrary programs that

utilize traditional mutual-exclusion-based programming techniques, exe- cute new programs written with explicit transactional constructs, and freely combine abstractions that use both coding styles. 15:30 - 17:00 Ptolemy: A Language with Quantified, Typed Events Hridesh Rajan - Iowa State University, USA Gary T. Leavens - University of Central Florida, USA Implicit invocation (II) and aspect-oriented (AO) languages provide re- lated but distinct mechanisms for separation of concerns. II languages have explicitly announced events that run registered observer methods. AO languages have implicitly announced events that run method-like but more powerful advice. A limitation of II languages is their inability to refer to a large set of events succinctly. They also lack the expressive

Technical papers papers Technical power of AO advice. Limitations of AO languages include potentially fragile dependence on syntactic structure that may hurt maintainability, and limits on the available set of implicit events and the reflective con- textual information available. Quantified, typed events, as implemented in our language Ptolemy, solve all these problems. This paper describes Ptolemy and explores its advantages relative to both II and AO languages. Prototyping and Composing Aspect Languages - using an Aspect Interpreter Framework Wilke Havinga, Lodewijk Bergmans, Mehmet Aksit - University of Twente, Netherlands Domain specific aspect languages (DSALs) are becoming more popular because they can be designed to represent recurring concerns in a way that is optimized for a specific domain. However, the design and implementation of even a limited domain-specific aspect language can be a tedious job. To address this, we propose a framework that offers a fast way to prototype implementations of DSALs. We briefly introduce the framework and its underlying model, as well as the workflow used when implementing DSALs. Subsequently, we show mappings of several domain specific aspect languages to demonstrate the framework. Since in our approach the DSALs are mapped to a common model, the framework provides an integrating platform allowing us to compose programs that use aspects written in multiple DSALs. The framework also provides explicit mechanisms to specify composition of advices written in multiple DSALs. 9

Assessing the Impact of Aspects on Exception Flows: An Exploratory Technical papers Study Roberta Coelho, Uira Kulesza, Arndt von Staa, Carlos Lucena - Computer Science Department – Pontifical Catholic University of Rio de Janeiro, Brazil Awais Rashid, Alessandro Fabricio Garcia, Nelio Cacho - Computing Department - Lancaster University, United Kingdom Fabiano Cutigi Ferrari - University of Sao Paulo / Lancaster University, Brazil / United Kingdom Exception handling mechanisms are intended to support the development of robust software. However, the implementation of such mechanisms with aspect-oriented (AO) programming might lead to error-prone scenarios. As aspects extend or replace existing functionality at specific join points in the code execution, aspects' behavior may bring new exceptions, which can flow through the program execution in unexpected ways. This paper presents a systematic study that assesses the error proneness of AOP mechanisms on exception flows of evolving programs. The analysis was based on the object-oriented and the aspect-oriented versions of three medium-sized systems from different application domains. Our findings show that exception handling code in AO systems is error-prone, since all versions analyzed presented an increase in the number of uncaught exceptions and exceptions caught by the wrong handler. The causes of such problems were characterized and presented as a catalogue of bug patterns.

THURSDAY, JULY 10TH 8:00 - 9:00 Registration 9:00 - 10:00 Invited Talk Concurrent Objects -- Retrospect and Prospect Akinori Yonezawa - Department of Information Science, University of Tokyo 10:00 - 11:30 UpgradeJ: Incremental Typechecking for Class Upgrades Gavin Bierman - Microsoft Research, UK Matthew Parkinson - University of Cambridge, UK James Noble - Victoria University of Wellington, NZ

One of the problems facing developers is the constant evolution of components that are used to build applications. This evolution is typical of any multi-person or multi-site software project. How can we program in this environment? More precisely, how can language design address such evolution? In this paper we attack two significant issues that arise from constant component evolution: we propose language-level extensions that permit multiple, co-existing versions of classes and the ability to dynamically upgrade from one version of a class to another, whilst still maintaining type safety guarantees and requiring only lightweight extensions to the runtime infrastructure. We show how our extensions, whilst intuitive, provide a great deal of power by giving a number of examples. Given the subtlety of the problem, we formalize a core fragment of our language and prove a number of important safety properties. Integrating Nominal and Structural Subtyping Donna Malayeri, Jonathan Aldrich - Carnegie Mellon University, USA Technical papers papers Technical Nominal and structural subtyping each have their own strengths and weaknesses. Nominal subtyping allows programmers to explicitly express design intent, and, when types are associated with run time tags, enables run-time type tests and external method dispatch. On the other hand, structural subtyping is flexible and compositional, allowing unantici- pated reuse. To date, nearly all object-oriented languages fully support one subtyping paradigm or the other. In this paper, we describe a core calculus for a language that integrates the key aspects of nominal and structural subtyping in a unified framework. We have also merged the flexibility of structural subtyping with statically typechecked external methods, a novel combination. We prove type safety for this language and illustrate its practical utility through examples that are not easily expressed in other languages. Our work provides a clean foundation for the design of future languages that enjoy the benefits of both nominal and structural subtyping. Flow Analysis of Code Customizations Anders Hessellund, Peter Sestoft - IT University of Copenhagen, Den- mark Inconsistency between metadata and code customizations is a major con- cern in modern, configurable enterprise systems. The increasing reliance on metadata, in the form of XML files, and code customizations, in the form of Java files, has led to a hybrid development platform. The ex- pected consistency requirements between metadata and code should be checked but often are not, so current tools offer surprisingly poor devel-

opment support. In this paper, we adapt classical data flow analyses to Technical papers detect inconsistencies and provide better static guarantees. We provide a formalization of the consistency requirements and a set of adapted analyses for a concrete case study. Our work is implemented in a fast and efficient prototype in the form of an Eclipse plugin. We validate our work by testing this prototype on actual production code; preliminary results show that this approach is worthwhile. We found a significant number of previ- ously undetected consistency errors and have received very positive feed- back from the developer community in the case study. 12:00 - 13:30 Online Phase-Adaptive Data Layout Selection Chengliang Zhang - Microsoft, USA Martin Hirzel - IBM, USA Good data layouts improve cache and TLB performance of object- oriented software, but unfortunately, selecting an optimal data layout a priori is NP-hard. This paper introduces layout auditing, a technique that selects the best among a set of layouts online (while the program is running). Layout auditing randomly applies different layouts over time and observes their performance. As it becomes confident about which layout performs best, it selects that layout with higher probability. But if a phase shift causes a different layout to perform better, layout auditing learns the new best layout. We implemented our technique in a product Java virtual machine, using copying generational garbage collection to produce different layouts, and tested it on 20 long-running benchmarks and 4 hardware platforms. Given any combination of benchmark and platform, layout auditing consistently performs close to the best layout for that combination, without requiring offline training. MTM2: Scalable Memory Management for Multi-Tasking Managed Runtime Environments Sunil Soman, Chandra Krintz - University of California, Santa Barbara, USA Laurent Daynes - Sun Microsystems Inc., France Multi-tasking, managed runtime environments (MREs) for modern type- safe, object-oriented programming languages enable isolated, concurrent execution of multiple applications within a single operating system process. Multi-tasking MREs can potentially extract high-performance on desktop and hand-held systems through aggressive sharing of classes and compiled code, and by exploiting high-level dynamic program information.

We investigate the performance of a state-of-the-art multi-taking MRE for concurrent program execution. We find that due to limited support for multi-tasking and performance isolation in the memory management subsystem, multi-tasking performs poorly compared to a production- quality, single-tasking MRE. We present MTM2: a comprehensive memory management system for concurrent multi-tasking. MTM2 facilitates performance isolation and efficient heap space usage through on-demand allocation of application- private regions. MTM2 mitigates fragmentation using a novel hybrid garbage collector that combines mark-sweep with opportunistic copying. Our evaluation shows that MTM2 improves overall performance, scal- ability, and footprint for concurrent workloads over state-of-the-art, multi- and single-tasking MREs. Externalizing Java Server Concurrency with CAL

Technical papers papers Technical Charles Zhang - Hong Kong University of Science and Technology, China Hans-Arno Jacobsen - University of Toronto, canada One of the important decisions about a server program is regarding its concurrency mechanisms. However, good concurrency models for general-purpose server programs are increasingly difficult to conceive as the runtime conditions are hard to predict. In this work, we advocate that the concurrency code is to be decoupled from server programs. To enable such separation, we propose and evaluate CAL, the Concurrency Aspect Library. CAL provides uniform concurrency programming abstractions and mediates the intrinsic differences among concurrency models. Through CAL, a server program is not tied to any particular concurrency model and framework. CAL can be configured without modifications to use concurrency frameworks of fundamentally different natures. The concurrency code based on CAL is simpler and looks closer to the design. Leveraging the customizability of CAL, we show that a commercial middleware server, refactored to use CAL, outperforms its original version by as much as 10 times 15:30 - 17:00 Regional Logic for Local Reasoning about Global Invariants Anindya Banerjee - Kansas State University, USA David Naumann, Stan Rosenberg - Stevens Institute of Technology, USA Shared mutable objects pose grave challenges in reasoning, especially for 13

data abstraction and modularity. This paper presents a novel logic for Technical papers error-avoiding partial correctness of programs featuring shared mutable objects. Using a first order assertion language, the logic provides heap- local reasoning about mutation and separation, via ghost fields and vari- ables of type `region' (finite sets of object references). A new form of modifies clause specifies write, read, and allocation effects using region expressions; this supports effect masking and a frame rule that allows a command to read state on which the framed predicate depends. Sound- ness is proved using a standard program semantics. The logic facilitates heap-local reasoning about object invariants: disciplines such as ownership are expressible but not hard-wired in the logic. A Unified Framework for Verification Techniques for Object Invari- ants Sophia Drossopoulou, Alexander J. Summers - Imperial College London, UK Adrian Francalanza - University of Southampton, UK Peter Mueller - Microsoft Research, Redmond, USA Object invariants define the consistency of objects. They have subtle semantics because of call-backs, multi-object invariants and subclassing. Several visible-state verification techniques for object invariants have been proposed. It is difficult to compare these techniques and ascertain their soundness because of differences in restrictions on programs and invariants, in the use of advanced type systems (e.g., ownership types), in the meaning of invariants, and in proof obligations. We develop a unified framework for such techniques. We distil seven parameters that characterise a verification technique, and identify suffi- cient conditions on these parameters which guarantee soundness. We instantiate our framework with three verification techniques from the literature, and use it to assess soundness and compare expressiveness. Extensible Universes for Object-oriented Data Models Achim Brucker - SAP Research, Germany Burkhart Wolff - Universität des Saarlandes, Germany We present a datatype package that enables the shallow embedding technique to object-oriented specification and programming languages. This datatype package incrementally compiles an object-oriented data model to a theory containing object-universes, constructors, accessors functions, coercions between dynamic and static types, characteristic sets, their relations reflecting inheritance, and the necessary class invariants. The pack- 14

age is conservative, i.e., all properties are derived entirely from axiomatic definitions. As an application, we use the package for an object-oriented core-language called IMP++, for which correctness of a Hoare-Logic with respect to an operational semantics is proven.

FRIDAY, JULY 11TH 8:00 - 9:00 Registration 9:00 - 10:00 Invited Talk Ambient-Oriented Programming: OOP without Wires and Threads Wolfgang De Meuter - Programming Technology Lab, Vrije Universiteit Brussel 10:00 - 11:30 Programming with Live Distributed Objects Technical papers papers Technical Krzysztof Ostrowski, Ken Birman, Jong Hoon Ahnn - Cornell Univer- sity, USA Danny Dolev - The Hebrew University of Jerusalem, Israel A component revolution is underway, bringing developers improved productivity and opportunities for code reuse. However, whereas existing tools work well for builders of desktop applications and client-server structured sys-tems, support for other styles of distributed computing has lagged. In this paper, we propose a new programming paradigm and a platform, in which instances of distributed protocols are modeled as "live distributed objects". Live objects can represent both protocols and higher-level components. They look and feel much like ordinary objects, but can maintain shared state and synchronization across multiple machines within a network. Live objects can be composed in a type-safe manner to build sophisticated distributed applications using a simple, intui-tive drag and drop interface, very often without writing any code or having to understand the intricacies of the underlying distributed algorithms. Bristlecone: A Language for Robust Software Systems Brian Demsky, Alokika Dash - University of California, Irvine, USA We present Bristlecone, a programming language for robust software systems. Bristlecone applications have two components: a high-level organization description that specifies how the application's conceptual operations interact, and a low-level operational description that specifies the sequence of instructions that comprise an individual conceptual

operation. Bristlecone uses the high-level organization description to Technical papers recover the software system from an error to a consistent state and to reason how to safely continue the software system's execution after the error. We have implemented a compiler and runtime for Bristlecone. We have evaluated this implementation on three benchmark applications: a web crawler, a web server, and a multi-room chat server. We developed both a Bristlecone version and a Java version of each benchmark application. We used injected failures to evaluate the robustness of each version of the application. We found that the Bristlecone versions of the benchmark applications more successfully survived the injected failures. Session-Based Distributed Programming in Java Raymond Hu, Nobuko Yoshida - Imperial College London, UK Kohei Honda - Queen Mary, University of London, UK This paper demonstrates the impact of integrating session types and object-oriented programming, through their implementation in Java. Ses- sion types provide high-level abstraction for structuring a series of interactions in a concise syntax, and ensure type-safe communications between distributed peers. We present the first full implementation of a language and runtime for session-based distributed programming featuring asynchronous message passing, delegation, and session subtyping and inter- leaving, combined with class downloading and failure handling. The compilation-runtime framework of our language effectively maps session abstraction onto underlying transports and guarantees communication safety through static and dynamic session type checking. We have implemented two alternative mechanisms for performing distributed session delegation and prove their correctness. Benchmark results show session abstraction can be realised with low runtime overhead. 12:00 - 13:30 ReCrash: Making Software Failures Reproducible by Preserving Object States Shay Artzi, Sunghun Kim, Michael D. Ernst - MIT Computer Science and Artificial Intelligence Lab, United States It is very hard to fix a software failure without being able to reproduce it. However, reproducing a failure is often difficult and time-consuming. This paper proposes a novel technique, ReCrash, that generates multiple unit tests that reproduce a given program failure. During every execution of the target program, ReCrash stores partial copies of method arguments

in memory. If the program fails (e.g., crashes), ReCrash uses the saved information to create unit tests reproducing the failure. We present ReCrashJ, an implementation of ReCrash for Java. ReCrashJ reproduced real crashes from Javac, SVNKit, Eclipsec, and BST. Re- CrashJ is efficient, incurring 13%-64% performance overhead. If this overhead is unacceptable, then ReCrashJ has another mode that has negligible overhead until a crash occurs and 0%-1.7% overhead until the crash occurs for a second time, at which point the test cases are generated. An Extensible State Machine Pattern for Interactive Applications Brian Chin, Todd Millstein - U.C. Los Angeles, United States The state design pattern is the standard object-oriented programming idiom for implementing the state machine logic of interactive applications. While this pattern provides a number of advantages, it does not Technical papers papers Technical easily support the creation of extended state machines in subclasses. We describe the extensible state design pattern, which augments the traditional state pattern with a few additional constraints that allow subclasses to easily add both new states and new events. Further, we observe that delimited continuations, a well-known construct from functional programming languages, supports state refinement in subclasses as well as the modular expression of control flow in the presence of interaction. We illustrate our pattern in the context of Java, leveraging its generics to obviate the need for dynamic typecasts and employing a small library that implements delimited continuations. We have used our pattern to simplify and modularize a widely used application written by others. Practical Object-Oriented Back-in-Time Debugging Adrian Lienhard, Tudor Gîrba, Oscar Nierstrasz - University of Bern, Switzerland Back-in-time debuggers are extremely useful tools for identifying the causes of bugs. Unfortunately the "omniscient" approaches that try to remember all previous states are impractical because they consume too much space or they are far too slow. Several approaches rely on heuris- tics to limit these penalties, but they ultimately end up throwing out too much relevant information. In this paper we propose a practical approach that attempts to keep track of only the relevant data. In contrast to other approaches, we keep object history information together with the regular objects in the application memory. Although seemingly counter-intuitive, this approach has the effect that data not reachable from current application objects (and hence, no longer relevant) is gar-

bage collected. We describe the technical details of our approach, and we Technical papers present benchmarks that demonstrate that memory consumption stays within practical bounds. Furthermore, the performance penalty is signifi- cantly less than with other approaches. 15:30 - 17:00 Inference of Reference Immutability Jaime Quinonez, Matthew Tschantz, Michael Ernst - MIT Computer Sci- ence and Artificial Intelligence Laboratory, USA Javari is an extension of Java that allows readonly type qualifiers that a typechecker uses to check for mutation errors. However, Javari programs will not typecheck unless all references in libraries used are annotated with Javari qualifiers. Manually converting existing Java libraries to Javari is tedious and error-prone. We present an algorithm for inferring reference immutability in Javari. The flow-insensitive and context-sensitive algorithm is sound; it produces results that typecheck in Javari. The algorithm is also precise; it infers the most readonly qualifiers possible without modifying the program. We have implemented the algorithm in a tool, Javarifier, that infers the Javari type qualifiers over class files. Javarifier automatically converts Java libraries to Javari. Additionally, Javarifier eases the task of converting legacy programs to Javari by inferring the mutability of every reference in a program. In case studies, Javari- fier correctly inferred mutability over Java programs of up to 110 KLOC. Computing Stack Maps with Interfaces Frédéric Besson - INRIA, France Thomas Jensen - IRISA/CNRS, France Tiphaine Turpin - IRISA/Université de Rennes 1, France Lightweight bytecode verification uses stack maps to annotate Java bytecode programs with type information in order to reduce the verification to type checking. This paper describes an improved bytecode analyser together with algorithms for optimizing the stack maps generated. The analyser is simplified in its treatment of base values (keeping only the necessary information to ensure memory safety) and enriched in its representation of interface types, using the Dedekind-MacNeille completion technique. The computed interface information allows to remove the dynamic checks at interface method invocations. We prove the memory safety property guaranteed by the bytecode verifier using an operational

semantics whose distinguishing feature is the use of untagged 32-bit values. For bytecode typable without sets of types we show how to prune the fix-point to obtain a stack map that can be checked without computing with sets of interfaces i.e., lightweight verification is not made more complex or costly. Experiments on three substantial test suites show that stack maps can be computed and correctly pruned by an optimized (but incomplete) pruning algorithm. How do Java Programs Use Inheritance? An Empirical Study of Inheritance in Java Software Ewan Tempero, Hayden Melton - University of Auckland, New Zealand James Noble - Victoria University of Wellington, New Zealand Inheritance is a crucial part of object-oriented programming, but its use in practice, and the resulting large-scale inheritance structures in pro-

Technical papers papers Technical grams, remain poorly understood. Previous studies of inheritance have been relatively small and have generally not considered issues such as Java's distinction between classes and interfaces, nor have they considered the use of external libraries. In this paper we present the first substantial empirical study of the large- scale use of inheritance in a contemporary OO programming language. We present a suite of structured metrics for quantifying inheritance in Java programs. We present the results of performing a corpus analysis using those metrics to over 90 applications consisting of over 100,000 separate classes and interfaces. Our analysis finds higher use of inheritance than anticipated, variation in the use of inheritance between interfaces and classes, and differences between inheritance within application types compared with inheritance from external libraries.

WEDNESDAY, JULY 9TH - THURSDAY, JULY 10TH Posters

P1 An Exception Handling Framework Nikolas Nehmer, University of Kaiserslautern, Germany Today’s exception handling mechanisms are insufficient for meeting the dependability requirements of large and complex software systems. In this poster session a novel exception handling framework is presented. The framework includes a tool supporting developers in reasoning about exception flow. Based on the exception flow analysis a novel fault contain- ment approach is proposed restricting the impact of uncaught exceptions on the overall system. System parts affected by uncaught exceptions are identified, isolated and gracefully degraded.

P2 Group Communication Abstractions for Distributed Reactive Systems Andoni Lombide Carreton, Stijn Mostinckx and Wolfgang De Meuter - Vrije Universiteit Brussel, Belgium Pervasive computing in mobile ad hoc networks requires that applications react to a plethora of events read by other de- vices in the mobile ad hoc network. Current context-aware and event-driven architectures require the programmer to react to these events via a carefully-crafted network of observ- ers and event handlers, around which the whole application is structured. The object-oriented, distributed and concurrent language AmbientTalk offers Reactive Programming as an alternative paradigm to be able to write such pervasive applications while retaining a conventional programming style. However, due to the asynchronous communication between remote objects, event handlers are still required to capture and process results computed in parallel. We claim that, by

exploiting the Reactive Programming mechanisms and the first class messages offered by AmbientTalk, it is possible to implement group communication abstractions that allow connecting asynchronous group communication with Reac- tive Programming without resorting to event handlers. We have identified a number of criteria to which such an ab-

Posters straction must adhere to to make this possible.

P3 A Pattern Language for Metadata Based Components Eduardo Martins Guerra, Aeronautical Institute of Technol- ogy, São José dos Campos, Brazil A metadata-based component is a component or a framework that processes its logic based on the metadata of the class whose instance it is working with. Metadata can be defined using code conventions, code annotations, external files, databases or programmatically. There are no docu- mented best practices or design patterns about this kind of components. This poster is going to present a pattern language for metadata-based components, addressing solutions about metadata-based components structure, metadata read- ing, logic processing based on metadata and metadata appli- cability.

P4 SASyLF: An Educational Proof Assistant for Language Theory Jonathan Aldrich, Robert J. Simmons, Key Shin - Carnegie Mellon University Teaching and learning formal programming language theory is hard, in part because it's easy to make mistakes and hard to find them. Proof assistants can help check proofs, but their learning curve is too steep to use in most classes, and is a barrier to researchers too. In this poster we present

SASyLF, an LF-based proof assistant specialized to checking Posters theorems about programming languages and logics. SASyLF has a simple design philosophy: language and logic syntax, semantics, and meta-theory should be written as closely as possible to the way it is done on paper. We include an example showing how to use SASyLF to formalize languages and their semantics, and how to prove meta-theorems about them. We also share our experience using SASyLF in a CMU course in Spring 2008.

P5 CZ: Multiple Inheritance Without Diamonds Donna Malayeri, Jonathan Aldrich - Carnegie Mellon Uni- versity Multiple inheritance has long been plagued with the “diamond” inheritance problem, spurring a variety of solutions, such as virtual inheritance, mixins and traits. We offer a different solution: a language that supports multiple inheritance but forbids diamond inheritance. We maintain expressiveness through a ``requires'' construct (inspired by Scala), which provides subtyping without inheritance diamonds, and a virtual super call similar to that found in traits. Our novel no-diamond restriction offers two benefits: it allows multiple inheritance to coexist neatly with fields, without the problem of initializing multiply-inherited fields. Second, it allow multiple inheritance to be compatible with modular typechecking of multiple dispatch; previous work disallowed multiple inheritance across module boundaries. We believe our language strikes the proper balance between expressiveness and modularity.

WEDNESDAY, JULY 9TH - THURSDAY, JULY 10TH

D1 The COSTA Cost and Termination Analyzer for Java Bytecode and its Web Interface E. Albert, P. Arenas - Complutense University of Madrid, Spain S. Genaim, G. Puebla, D. Ramírez, and D. Zanardini (Technical University of Madrid, Spain)

COSTA is a research prototype which performs automatic Demonstrations program analysis and which is able to infer cost and termination information about Java bytecode programs. The system receives as input a bytecode program and a cost model cho- sen from a selection of resource descriptions, and tries to bound the resource consumption of the program with respect to the given cost model. COSTA provides several non- trivial notions of resource, such as the amount of memory allocated on the heap, the number of bytecode instructions executed, the number of billable events (such as sending a text message on a mobile phone) executed by the program. When performing cost analysis, COSTA produces a cost equation system, which is an extended form of recurrence relations. In order to obtain a closed (i.e., non- recursive) form for such recurrence relations which repre- sents an upper bound, COSTA includes a dedicated solver. An interesting feature of COSTA is that it uses pretty much the same machinery for inferring upper bounds on cost as for proving termination (which also implies the boundedness of any resource consumption). The COSTA web interface allows users to try out the system on a set of representative examples, and also to upload their own bytecode programs. As the behaviour of COSTA can be customized using a relatively large set of options, the web 23

interface offers two different alternatives for choosing the Demonstrations values for such options. The first alternative, which we call automatic, allows the user to choose from a range of possibili- ties which differ in the analysis accuracy and overhead. All this, without requiring the user to understand the different options implemented in the system and their implications in analysis accuracy and overhead. The second alternative is called manual and it is meant for the expert user. There, the user has access to all of the analysis options available, allowing a fine-grained control over the behaviour of the analyzer. Some of these options include whether to analyze the Java standard libraries, to take exceptions into account, to perform a number of pre-analyses, to write/read analysis results to file in order to reuse them in later analyses, etc. In the demo, we will show analyses using different cost models and also analyze applications for both Standard Edition Java and Micro Edition Java (in particular, for the MIDP profile for mobile phones).

D2 Building and using pluggable type systems with the Checker Framework Michael D. Ernst, Massachusetts Institute of Technology

A static type system helps programmers to detect and prevent errors. However, a language's built-in type system does not help to detect and prevent enough errors, because it cannot express certain important invariants. A user-defined, or pluggable, type system enriches a language's built-in type system via type qualifiers. Pluggable types permit more expressive compile-time checking, and they can guarantee the absence of additional errors. Example type qualifiers include non- null, readonly, interned, and tainted. Despite considerable interest in user-defined type qualifiers,

previous frameworks have been too inexpressive, unscalable, or incompatible with existing languages or tools. This has hindered the evaluation, understanding, and uptake of pluggable types. The Checker Framework supports adding pluggable type systems to the Java language in a backward-compatible way. The Checker Framework is useful to two constituencies. A type system designer can create a type-checker for a custom type system. A programmer can use the type-checker to detect errors or verify their absence. The Checker Framework is expressive and flexible. It builds in many features needed by type system designers and pro- Demonstrations grammers, including: • backward-compatible Java and classfile syntax for type qualifiers • integration with javac and Eclipse • three type inference tools to ease programmer annota- tion burden • declarative and procedural syntax for writing typechecking rules • flow-sensitive type qualifier inference • polymorphism over types (Java generics) • polymorphism over type qualifiers • implicit and default qualifiers Experience indicates that the Checker Framework is useful to programmers and type system designers. For programmers, type-checkers built using the Checker Framework have processed over 600K lines of code, finding real errors in every program. For type system designers, the checkers are concise, even for robust implementations of sophisticated type systems, and the simplest type systems require writing

no code at all. The Checker Framework is being used by re- Demonstrations searchers around the world to perform realistic evaluation of type systems. It has yielded new insight into existing type systems and has enabled the creation and evaluation of new ones. This demonstration will illustrate the power of the Checker Framework, both for programmers and for type system designers, and will prepare you to begin using it yourself. The Checker Framework is freely available at: http://groups.csail.mit.edu/pag/jsr308/ . The distribution includes source code, binaries, extensive documentation, and example type-checkers.

D3 The Maxine Virtual Machine B. Mathiske, L. Daynes, D. Simon, B. Titzer, M. Van De Vanter (Sun Microsystems Laboratories)

Sun Microsystems Laboratories has just released under GPL v2.0 a preview version of the Maxine VM, a new research virtual machine written in the Java programming language that emphasizes ease of development, portability, maintainability, and configurability. Maxine seeks to make VM development substantially more agile than has been possible in the past. It is also the first metacircular VM implementation integrated with the latest JDK software from Sun. VM developers can work with the Maxine code base in their choice of NetBeans software, Eclipse, or IntelliJ, and need not be concerned with complications such as makefiles, Ant files, or preprocessors. Maxine's source code leverages all the newest language features, including generics, annotations, return type overloading, enums, etc., and exemplifies system

programming in the Java programming language. The design of Maxine is modular and enables the construction of different VMs based on different choices for configurable features, including dynamic compilers for Just-in- Time compilations and/or VM image generation, dynamic recompilation strategies, garbage collectors, read and write barriers, object reference representations, object layouts, thread synchronization, and VM machine startup sequence. All internal data structures of the VM (e.g., runtime representation of classes, bytecode and native representation of methods, etc...) are first-class Java objects. This enables their reification by serviceability tools inspecting a remote run- Demonstrations ning Maxine VM. This ability has eased considerably the construction of the Maxine Inspector: a visual debugging tool that seamlessly integrates object browsing with both source-level and low-level (i.e., native machine instructions) debugging. The demonstration will begin with a tour of the Maxine VM from a developer's perspective, illustrating the various steps a Maxine VM developer go through: installing sources, editing code, configuring and building a VM image, unit testing, running the VM with Sun JDK 1.6, and debugging using the Maxine Inspector. The demonstration then focuses on the Maxine Inspector. The inspector will be first used to show on a live Maxine VM prominent internal mechanisms of the VM, such as bootstrapping, dynamic link resolution and class loading, runtime compilation, signal usage, exception handling, etc. Then, we will illustrate how the Inspector ease the identifica- tion of bugs in the Maxine VM, and help improving the productivity of VM developers. The Maxine Virtual Machine and Inspector are both available at https://maxine.dev.java.net.

D4 The g-Eclipse Project Demonstrations Harald Gjermundrød and Marios D. Dikaiakos on behalf of the g-Eclipse consortium

The g-Eclipse project - both a European funded research project and an Eclipse technology project - is building an integrated workbench framework to access the power of existing Grid infrastructures on top of the reliable ecosystem of the Eclipse community to enable a sustainable development. The g-Eclipse team develops a middleware-independent platform by providing extension points to connect to different Grid infrastructures. The framework itself comes with exemplary gLite support and support for the GRIA middleware. The implementation of support for Amazon Web Service (AWS) is currently underway. With the help of g-Eclipse, Grid users can easily access their personalized Grid resources. Further- more, Grid resource providers profit from a shortening of the service-to-market time and Grid application developers benefit from the seamless integration of the remote development process into the existing Eclipse development environments using g-Eclipse. Current Stage of the Project: The g-Eclipse project started in July 2006 and the EU-funded part will end in December 2008. As the project is also an offi- cial Eclipse project its sustainability will continue as an open source Eclipse project with other national and EU-funded projects extending/using the framework. Monthly milestone releases are created and made freely available for download from the www.eclipse.org/geclipse or www.geclipse.eu web- sites. The latest stable release is version 0.5 (released Septem- ber 2007) and the current milestone release is 1.0 milestone 6 Features Highlights:

The framework comes with three pre-defined perspectives, namely user, operator, and developer. Each of these perspective contains a set of features including the ones below: User Perspective: 1) Create a Grid project 2) Create a job description following the JSDL standard 3) Submit a job to the Grid and retrieve its output 4) Mount Grid Storage Elements and browse, drag and drop, open files on the Grid Operator Perspective: Demonstrations 1) Manage a local Grid site 2) Specify and submit service jobs to the Grid 3) Browse available Grid resources and their properties Developer Perspective: 1) Remote debugging of Grid jobs 2) Scientific visualization

D5 SwingBean: Graphical Components Based on Class Metadata Eduardo Martins Guerra, Aeronautical Institute of Technol- ogy, São José dos Campos, Brazil

In the MVC model, the view layer is the hardest to have its classes reused, because the graphical-interface components that compound a screen depend of the domain entities. For example, a form or a table usually contains elements that can be mapped to some class property. Using class metadata to create graphical components, the domain specific portion

of a screen can be abstracted and it will enable the reuse in Demonstrations the view layer. SwingBean is an open-source framework that provides metadata based graphical components to be used in Java with the Swing API. It has more than 2500 downloads and was al- ready used successfully in large scale applications in the production phase and for teaching how to create graphical interfaces in Java. With SwingBean it is very easy to create templates that can be used directly to create more than one screen just configuring properties. SwingBean also has func- tionalities to: validate information based on metadata; create binding between domain objects and graphical components and set and retrieve information in the components. The demonstration will present the SwingBean framework and how it can use the class structure and some additional metadata configured in an XML document to create complex forms and tables. The creation of simple templates will also be demonstrated to show how the reuse in the view layer could be archived using this kind of approach. The demonstration will be made interactively with a "live implementation" of screens.

INVITED TALKS ROOM: AKAMAS A Invited Talk 1 - The Clojure Programming Language Rich Hickey (Independent Software Designer) Customers and stakeholders have substantial investments in, and are comfortable with the performance, security and stability of, industry- standard platforms like the JVM and CLR. While Java and C# developers on those platforms may envy the succinctness, flexibility and productivity of dynamic languages, they have concerns about running on cus- tomer-approved infrastructure, access to their existing code base and libraries, and performance. In addition, they face ongoing problems deal- ing with concurrency using native threads and locking. Clojure is an effort in pragmatic dynamic language design in this context. It endeavors to be a general-purpose language suitable in those areas where Java is suitable. It reflects the reality that, for the concurrent programming future, pervasive, unmoderated mutation simply has to go. Clojure meets its goals by: embracing an industry-standard, open platform - the JVM; modernizing a venerable language - Lisp; fostering functional programming with immutable persistent data structures; and providing built-in concurrency support via software transactional memory and asynchronous agents. The result is robust, practical, and fast. This talk will focus on the motivations, mechanisms and experiences of the implementation of Clojure. Rich Hickey, the author of Clojure, is an independent software designer, consultant and application architect with over 20 years of experience in all facets of software development. Rich has worked on scheduling systems, broadcast automation, audio analysis and fingerprinting, database design, yield management, exit poll systems, and machine listening, in a variety of languages.

Invited Talk 2 - Language Design: Back to the Future? Laurence Tratt (Bournemouth University) Programming languages are the medium used to express our wishes to a computer. Unlike human languages, we can alter, destroy, and create Dynamic Languages Symposium 2008 Dynamic Languages them at will. Despite this, mainstream programming languages are surprisingly homogeneous with the differences between them often amount- ing to little more than surface syntax issues. New ideas rarely get a toe- hold in the marketplace and those that do have typically been used for decades by a sizeable minority (e.g. dynamic typing). In this talk the speaker will suggest reasons for the inherent conservativeness of programming languages, their designers, and their users. He will look back at some largely forgotten languages - some older than others - that intro- duced distinctive language features, and offer thoughts on their successes and failures. He will show how a series of seemingly outlandish ideas 31

scavenged from such languages can be blended together to form part of a Dynamic Languages Symposium 2008 coherent modern language - one that also aims to try and inject a few new memes of its own into the languages pool. Laurence Tratt is a Senior Lecturer at Bournemouth University and software consultant. He is the chief designer of the Converge programming language. His research interests include programming languages, domain specific languages, and software modelling.

Invited Talk 3 - The Lively Kernel - Just for Fun, Let's Take JavaScript Seriously Dan Ingalls (Sun Microsystems Laboratories) The Sun Labs Lively Kernel is a new approach to Web programming. It provides a complete platform for Web applications, including dynamic graphics, network access, and development tools, and requires nothing more than available web browsers. We call the system "lively" for three reasons. It comes live off a web page. There is no installation. The entire system is written in JavaScript, and it becomes active as soon as the page is loaded by a browser. It can change itself and create new content. The Lively Kernel includes a basic graphics editor that allows it to alter and create new graphical content, and also a simple IDE that allows it to alter and create new applications. It comes with a basic library of graphical and computational components, and these, as well as the kernel, can be al- tered and extended on the fly. It can save new artifacts, even clone itself, onto new web pages. The kernel includes WebDAV support for browsing and extending remote file systems, and thus has the ability to save its objects and "worlds" (applications) as new active Web pages. The Lively Ker- nel uses only existing Web standards. The implementation and user language is JavaScript, known by millions and supported in every browser. The graphics APIs are built upon SVG (Scalable Vector Graphics), also available in major browsers. The network protocols used are asynchronous HTTP and WebDAV. The speaker will demonstrate the Lively Ker- nel and discuss various aspects of JavaScript as a programming language. Dan Ingalls has been the principal architect of five generations of Small- talk environments. He designed the byte-coded virtual machine that made Smalltalk practical in 1976. He also invented BitBlt, the general-purpose graphical operation that underlies most bitmap graphics systems today, as well as pop-up menus. He has received the ACM Grace Hopper Award for Outstanding Young Scientist, and the ACM Software Systems Award. Dan is currently at Sun Microsystems where he is working on Lively, a new kernel for JavaScript, that will offer the reflective capabilities needed for proper development support, as well as in-browser support for other high-level languages.

REGISTRATION TIMES: - Sunday July 6th. 18:00 - 21:00 - Monday July 7th. 08:00 - 09:00 - Tuesday July 8th. 08:00 - 09:00 - Wednesday July 9th. 08:00 - 09:00

MONDAY, JULY 7TH Social Events - Wecome Reception @ 20:00. Meet in the lobby

WEDNESDAY, JULY 9TH - Wecome Reception @ 20:00. Meet in the lobby

THURSDAY, JULY 10TH - Dinner (Time to be announced). Meet in the lobby

Conference Site InformationConference Site

Conference Site Information Conference Site Information

InformationConference Site

TELEPHONE INFORMATION If you are dialing a Cypriot number from your mobile phone, you need to firstly dial the international code for Cyprus (00357), and then the number. For example, if dialing Paphos 26123456, you need to enter 00357-26123456. For Directory Enquiries, dial 11892 (to look up telephone numbers in Cyprus).

TAXI SERVICES Acropolis Taxis...... 26951584 Anemone Taxis ...... 26912131 Aphrodite Taxis...... 26934555 If you need to specify drop-off / pick-up points, the following information may be helpful: The ECOOP’08 conference venue is the Coral Beach Resort.

NFORMATION FFICES General Information TOURIST I O Paphos ...... 26932841 Paphos airport ...... 26423161

LOCAL BUS TIMETABLES Buses from Kato (Lower) Paphos to: Coral Bay, locally on ALEPA bus No 10 (summer daily 8am-7 pm every 20 min, 7.30-11 pm every 25 min; winter daily 8am- 6 pm every 20min; 40 min) More information about buses can be found at: http://www.cyprus.com/cyprus-general-info-transportation-bus-services- intercity.php RESTAURANTS There are a number of very good restaurants in Paphos catering for a variety of cuisines like: Fetta’s Tavern (Traditional Meze Tavern) Arch. Makariou III Ave, Pafos City, Paphos, Cyprus 26937822 Il Classico (French cuisine with a touch of the Mediterranean) 13 Nikou Georgiou, 8035, Paphos. 26939777

The Rib Shack (Tex-Mex Cuisine) Information General 65 Poseidonos Ave., Paphos. 26964083 / 84 Chloe’s (Chinese Cuisine) 13, Posidonos Ave, Paphos. 26934676

ENTERTAINMENT VENUES Galway is home to a number of excellent theatres, music venues, and cinemas. For a list of what’s on in Galway, you should get a free copy of the Galway Advertiser which is available from most newspaper outlets or from the head office in Eyre Square (city centre).

EMERGENCY NUMBERS In an emergency, dial 112 (free of charge) Ask for the emergency service that you require: Ambulance Police (112 or 199) Give the address or location where help is needed. Making nuisance calls to the 112 emergency services is a criminal offence.

DOCTORS Michalis Markou 99647001, 26947000

PHARMACIES The nearest pharmacies to the conference venue are: Anna Mihail. Poseidonos Ave. 25, 8042 Paphos, 26222077 Niki Christofi, Poseidonos Ave. 34, 8042 Paphos, 26964526

PHARMACIES (AFTER HOURS) Paphos ...... 90901416

ORGANIZING COMMITTEE George A. Papadopoulos, University of Cyprus, CY - Conference Chair Patrick Eugster, Purdue, US - Workshop Chair Costas Pattichis, University of Cyprus, CY - Workshop Chair James Noble, Victoria University, NZ - Tutorial Chair Dave Clarke, CWI, NL - Publicity Chair Mark Hills, UIUC, US - PhD Symposium Chair

Committees Andreas Andreou, University of Cyprus, CY - Exhibition Chair Anna Phillipou, University of Cyprus, CY - Demonstration and Poster Chair Tobias Wrigstad, Stockholm University, SE - Student Volunteer Chair Tony Hosking, Purdue, US - Panel Chair

PROGRAM COMMITTEE Jan Vitek, Purdue University, US - PC Chair Elisa Baniassad, Chinese University of Hong Kong, HK Gavin Bierman, Microsoft Research, UK Alex Buckley, Sun Microsystems, US William Cook, University of Texas at Austin, US Susan Eisenbach, Imperial College, UK Manuel Fahndrich, Microsoft Research, US Pascal Felber, University of Neuchatel, CH Robby Findler, University of Chicago, US Kathleen Fisher, ATT Research, US Jeff Foster, University of Maryland, College Park, US Michael Haupt, Hasso Plattner Institute, DE Matthias Hauswirth, University of Lugano, CH Görel Hedin, Lund University, SE Richard Jones, University of Kent, UK

Doug Lea, State University of New York at Oswego, US Committees Ondrej Lhotak, University of Waterloo, CA Todd Millstein, University of California Los Angeles, US James Noble, Victoria University, NZ Nathaniel Nystrom, IBM Research, US Manuel Oriol, ETH Zurich, CH Erez Petrank, Technion and Microsoft Research, IL Frantisek Plasil, Charles University, CZ Awais Rashid, Lancaster University, UK Michael I. Schwartzbach, University of Aarhus, DK Jeremy G. Siek, University of Colorado at Boulder, US Mario Sudholt, EMN-INRIA, LINA, FR Peter Theimann, Universtiaet Freiburg, DE Frank Tip, IBM Research, US Eelco Visser, Delft University of Technology, NL Tobias Wrigstad, Stockholm University, SE Roel Wuyts, IMEC and KULeuven, BE

WORKSHOP COMMITTEE Patrick Eugster, Purdue University, USA - Co-chair Benoit Garbinato, University of Lausanne, CH - Member Peter Müller, Microsoft Research, USA - Member Costas Pattichis, University of Cyprus, CY - Co-chair Friedrich Steimann, Fernuniversität Hagen, DE - Member

1. Alex Summers

2. Andoni Loumbide Carreton

3. Angel Nunez

4. Eduardo Guerra

5. Eline Philips

6. Johan Ostlund

7. Lukasz Ziarek

8. Nicholas Cameron

Student Volunteers Student Volunteers 9. Sebastian Gotz

10. Stephen Nelson

11. Chrysoulis Zambas

12. Maria Patrickson

13. Niklas Björkén

MONDAY, JULY 7TH Conference Program

8:00 - 9:00 Registration 9:00 - 10:00 10:00 - 10:45 Workshops 10:45 - 11:30

11:30 - 12:00

12:00 - 13:00 Workshops

13:00 - 15:30

15:30 - 17:00 Workshops

Workshops will be held in the Akamas A, Akamas , Akamas C, Aphrodite A, Aphrodite B, Leda, Athena and Zeus rooms. Please check the room for each workshop at the workshop pages in this guide.

TUESDAY, JULY 8TH

DLS ‘08

8:00 - 9:00 Registration Registration 9:00 - 10:00 Invited Talk 1 10:00 - 10:45 Workshops Research Papers 1 10:45 - 11:30

11:30 - 12:00

12:00 - 13:00 Workshops Invited Talk 2 Conference Program 13:00 - 13:30 Research Papers 2

13:30 - 15:00

15:00 - 15:30 Research Papers 3 15:30 - 16:00 Workshops 16:00 - 17:00 Invited Talk 3

Workshops will be held in the Akamas A, Akamas , Akamas C, Aphrodite A, Aphrodite B, Leda, Athena and Zeus rooms. Please check the room for each workshop at the workshop pages in this guide. DLS’08 will be held in the Akamas A conference room.

WEDNESDAY, JULY 9TH Conference Program

8:00 - 9:00 Registration 9:00 - 10:00 Invited Talk

10:00 - 10:45 Technical Summer

10:45 - 11:30 Papers School

11:30 - 12:00

Technical Summer Posters / 12:00 - 13:00 Papers School Demos

13:00 - 15:30

Technical Summer Posters / 15:30 - 17:00 Papers School Demos

The main conference will be held in the Akamas A conference room. The Summer School will be held at the Akamas B conference room. The Posters will be placed in the foyer of the conference site. The Demonstrations will be held in the Akamas C conference room.

THURSDAY, JULY 10TH

8:00 - 9:00 Registration 9:00 - 10:00 Invited Talk 10:00 - 10:45 Technical Summer Posters / 10:45 - 11:30 Papers School Demos

11:30 - 12:00

Technical Summer Posters / 12:00 - 13:00 Papers School Demos Conference Program

13:00 - 15:30

Technical Summer Posters / 15:30 - 17:00 Papers School Demos

FRIDAY, JULY 11TH Conference Program

8:00 - 9:00 Registration 9:00 - 10:00 Invited Talk 10:00 - 10:45 Technical Papers Summer School 10:45 - 11:30

11:30 - 12:00

12:00 - 13:00 Technical Papers Summer School

13:00 - 15:30

15:30 - 17:00 Technical Papers Summer School

The main conference will be held in the Akamas A conference room. The Summer School will be held at the Akamas B conference room.

The Software Engineering and Internet Technologies Labora- tory (SEIT) focuses its research activities on two important areas of Information Technology, namely Software Engineer- ing and Internet Technologies. In the first area, SEIT concentrates on the development of Component-Based Systems, Software Architectures and Architecture Description Lan- guages, Middleware Platforms and software for embedded systems. In the second area, the Laboratory concentrates on XML technologies, Multimedia Frameworks, Cooperative Information Systems, Mobile Computing, Open and Dis- tance Learning, E-Commerce, e-Health, Web Services, and Service Oriented Computing. SEIT was actively involved in the 5th and 6th Framework, where it participated in 10 EU funded projects, 7 IST ones and 3 more belonging to the EUMEDIS (E.U. Mediterra- nean Information Society) initiative. The Laboratory has also been involved in other EU funded initiatives, notably ESIS (European Survey in Information Society), but also the Leonardo Da Vinci framework on Vo- cational Training where it has participated in 8 such funded projects. The Laboratory currently occupies 12 personnel, including 3

SEIT Lab @ University of Cyprus post doctoral scientists and 4 postgraduate ones. For details on research programs, including doctoral studies and postdoctoral opportunities, please contact our lab direc- tor: Prof. George A. Papadopoulos Department of Computer Science University of Cyprus 75 Kallipoleos Street P.O. Box 20537, CY-1678 Nicosia, CYPRUS

CONFERENCE COORDINATOR

DREAMSCAPE CONFERENCES ADDRESS: P.O.BOX 24420, Nicosia 1704, Cyprus. EMAIL: [email protected] EMAIL: [email protected] URL: www.cyprusconferences.org URL: www.cyprusdmc.com TEL +357-22-591900 FAX +357-22-591700

In case of an emergency, please contact:

Mr. Petros Stratis 24/7 at +357-99-653444

Organized by:

Association Internationale University of Cyprus pour les Technologies Objets

In collaboration with:

Supported by:

SILVER

ecoop 2008