title: CompGen: generation of fast JIT compilers in a multi-language VM

authors:
Florian Latifi
David Leopoldseder
Christian Wimmer
Hanspeter Mössenböck

abstract:
The first Futamura projection enables compilation and high performance code generation of user programs by partial evaluation of language interpreters. Previous work has shown that online partial evaluation can yield the same peak performance as a specialized JIT compiler. However, this comes with the downside of additional compile time: Online partial evaluation of language interpreters has to specialize interpreter code on the fly to the dynamic types used at run time to create efficient target code. As a result, the time spent on partial evaluation itself is a significant contributor to the overall compile time of a method.

The second Futamura projection solves this problem by self-applying partial evaluation on the partial evaluation algorithm, effectively generating language-specific compilers from interpreters. This typically reduces compilation time compared to the first projection. Previous work employed the second projection to some extent, however we are not aware of any usage of the generic second Futamura projection in a state-of-the-art language runtime.

To solve the problems of self-application and code-size explosion, this paper proposes CompGen, an approach based on code generation of subsets of language interpreters. It is loosely based upon the idea of the second Futamura projection. Our implementation of CompGen for GraalVM shows that our usage of a novel code-generation algorithm allows us to generate efficient compilers that emit fast target programs which easily outperform the first Futamura projection in compilation time. We evaluated our approach with the high-performance JavaScript implementation of GraalVM and standard JavaScript benchmarks, showing that our approach achieves >2X speedups of partial evaluation.


venue: dls

title: Analyzing permission transfer channels for dynamically typed languages

authors:
Théo Rogliano
Guillermo Polito
Luc Fabresse
Stéphane Ducasse

abstract:
Communicating Sequential Process (CSP) is nowadays a popular concurrency model in which threads/processes communicate by exchanging data through channels. Channels help in orchestrating concurrent processes but do not solve per-se data races. To prevent data races in the channel model, many programming languages rely on type systems to express ownership and behavioural restrictions such as immutability. However, dynamically-typed languages require run-time mechanisms because of the lack of type information at compile-time.

In this paper, we propose to augment channels with four different permission transfer semantics. We explore two mechanisms to implement such permission transfers at run time: write barriers and partial-read barriers. To validate our approach we implemented a channel framework in Pharo, and we extended it with different permission transfer semantics. We report on performance measurements of both (a) the transfer overhead on a single object and on a graph of objects, and (b) the per-object access overhead incurred by ownership checks. This work stands as a cornerstone of future work on adaptive optimizations for permission transfer channels.


title: Runtime and compiler support for HAMTs

authors:
Sona Torosyan
Jon Zeppieri
Matthew Flatt

abstract: Many functional languages---including Racket, Clojure, and Scala---provide a persistent-map datatype with an implementation based on Hash Array Mapped Tries (HAMTs). HAMTs enable efficient functional lookup, insertion, and deletion operations with a small memory footprint, especially when taking advantage of implementation techniques that have been developed since the original HAMT implementation. Racket's latest HAMT implementation is based on an intermediate data structure, a stencil vector, that supports an especially compact representation of HAMTs with help from the compiler and memory manager. That is, stencil vectors provide an abstraction to improve HAMT performance without burdening the compiler with all of the complexity and design choices of a HAMT implementation. Benchmark measurements show that HAMTs in Racket have performance comparable to other state-of-the-art implementations, while stencil-vector HAMTs are more compact and run as fast as alternative representations in Racket. Although we only report on Racket, our experience suggests that a stencil-vector datatype in other dynamic-language implementations might improve HAMT performance in those implementations.


title: Who You Gonna Call: Analyzing the Run-Time Call-Site Behavior of Ruby Applications

authors:
Sophie Kaleba
Octave Larose
Richard Jones
Stefan Marr

abstract: Applications written in dynamic languages are becoming larger and larger and companies increasingly use multi-million line codebases in production. At the same time, dynamic languages rely heavily on dynamic optimizations, particularly those that reduce the overhead of method calls. In this work, we study the call-site behavior of Ruby benchmarks that are being used to guide the development of upcoming Ruby implementations such as TruffleRuby and YJIT. We study the interaction of call-site lookup caches, method splitting, and elimination of duplicate call-targets. We find that these optimizations are indeed highly effective on both smaller and large benchmarks, methods and closures alike, and help to open up opportunities for further optimizations such as inlining. However, we show that TruffleRuby’s splitting may be applied too aggressively on already-monomorphic call-sites, coming at a run-time cost. We also find three distinct patterns in the evolution of call-site behavior over time, which may help to guide novel optimizations. We believe that our results may support language implementers in optimizing runtime systems for large code-bases built in dynamic languages.


title: Execution vs. Parse-Based Language Servers: Tradeoffs and Opportunities for Language-Agnostic Tooling for Dynamic Languages

authors:
Stefan Marr
Humphrey Burchell
Fabio Niephaus

abstract:
With the wide adoption of the language server protocol, the desire to have IDE-style tooling even for niche and research languages has exploded. The Truffle language framework facilitates this desire by offering an almost zero-effort approach to language implementers to providing IDE features. However, this existing approach needs to execute the code being worked on to capture much of the information needed for an IDE, ideally with full unit-test coverage.

To capture information more reliably and avoid the need to execute the code being worked on, we propose a new parse-based design for language servers. Our solution provides a language-agnostic interface for structural information, with which we can support most common IDE features for dynamic languages.

Comparing the two approaches, we find that our new parse-based approach requires only a modest development effort for each language and has only minor tradeoffs for precision, for instance for code completion, compared to Truffle's execution-based approach.

Further, we show that less than 1,000 lines of code capture enough details to provide much of the typical IDE functionality, with an order of magnitude less code than ad hoc language servers. We tested our approach for the custom parsers of Newspeak and SOM, as well as SimpleLanguage's ANTLR grammar without any changes to it. Combining both parse and execution-based approaches has the potential to provide good and precise IDE tooling for a wide range of languages with only small development effort. By itself, our approach would be a good addition to the many libraries implementing the language server protocol to enable low-effort implementations of IDE features.


title: All Languages Are Dynamic (Invited Talk)

abstract: Virtual Machines, Dynamic Compllers, and Implementation Frameworks make dynamic langauges easier and more efficient to optimize. Meanwhile, IDEs, provers, dependent types, type inferencers, and (so-called) “generative AI” mean programmers can express - statically - more information about the dynamic behaviour of their programs. Component libraries in these languages will come with assertions and proofs of their behaviour, and their advocates fantasise about transforming programming into the composition of dependently-typed higher-order yoneda morphisms, ensuring programs are correct-by-construction (where that construction is carried out by yet more generative AI). In this talk, I’ll speculate about what the resulting world will be like for programmers. Rather than a static world of platonic mathematical abstractions, I argue that the opposite will be true: that all languages will be dynamic.


title: Language Runtimes for the New Cloud Era (Invited Talk)

abstract: Programming languages offer a number of abstractions such as dynamic typing, sandboxing, and automatic garbage collection which, however, come at a performance cost. Looking back, the most influential programming languages were proposed at a time when Moore’s Law was still in place. Nowadays, post-Moore’s law, scalability, and elasticity become crucial requirements, leading to an increasing tension between programming language design and implementation, and performance. It is now time to discuss the impact of programming languages and language runtimes in the context of scalable and elastic cloud computing platforms with the goal of forecasting their role in the new cloud era.


title: Is Polyglot Programming Really a Thing? (Invited Talk)

abstract: Polyglot programming is the practice of writing an application with multiple languages to capture additional functionality and efficiency not available to a single language. This happens more often than people think. Some reasons are: to support different platforms (e.g., Android, iOS), to be more efficient on some parts, to take advantage of features unique to a different ecosystem (e.g., dedicated APIs). But are we ready for polyglot programming? This talk will try to explore the open issues from the point of view of both the multiple programming language integration and from the software engineering development for polyglot programming.


title: Are We Heading towards a Dynamic Language Winter? (Invited Talk)

abstract: Though the 2010s saw many research publications about languages such as JavaScript and Python, there currently appears to be a general loss of interest in dynamic languages, with popular new languages such as Rust and Zig being statically typed, and AOT compilation often being viewed as a preferable option to JIT compilation. There is a legitimate question as to whether we are headed towards, or already in, a dynamic language “winter”, with reduced interest from industry and reduced access to funding for dynamic language research. However, despite this, many of the most popular languages (Python, JS, Julia, etc.) are still dynamically typed. In this talk, we discuss questions such as potential causes for a dynamic language winter, what makes statically typed languages so attractive at this time, the major strengths of dynamic languages that could help turn the tide, and what may come after.


title: Programming Languages for AI Programing Agents (Invited Talk)

abstract:
Over the past decade software development has shifted from a process centered around writing code to a process that increasingly involves composition of external packages and managing the integration of code from other team members. The next decade-plus will be defined by the shift from a process where humans are the central developers of code into one where AI agents, likely Large Language Model (LLM) based, will be the major creators of code and humans will shift to a supervisory role as curators, integrating rich framework-functionality and code developed by AI programming agents.

In this new world we must ask ourselves – are programming languages as they exist today fit for purpose and how do they evolve to meet the needs of this future programming model. This talk represents an opinionated take on the question and attempts to outline specific areas of investigation that need to be addressed by the PL community as part of this journey including:

What programming language features help/hinder AI agents when understanding and generating code?

What programming language features help/hinder human agents when working with an AI Copilot?

What programming language tools are needed to empower AI agents in creating grounded and reliable outputs?

How can intents be expressed as part of the program representation – examples, constraints, natural language, external documents?

How do we empower end-users as part of this transformation?

What programming language features are needed to support new AI driven workflows – live coding, interactive requirement gathering, AI TDD?

Effectively answering these questions plays a key role in determining if AI driven programming represents a revolution in how software is developed or is limited to being a programming productivity aid for existing development workflows. As such our community should play a central role in understanding this space and leading in the development of this technological transformation!


title: JITs Are Nice, but Why Aren't We Using Them? (Invited Talk)

abstract: Dynamic languages have evolved quite a bit over the past few decades. While there’s always room for improvement, the current generation of languages have rich semantics and expressive syntax, making for a pleasant developer experience. Developers can clearly represent ideas, decreasing the maintenance burden while supporting rapid development. Dynamic languages such as Python, Ruby, JavaScript, PHP, and Lua power a substantial portion of web applications and services today. However, diminishing returns in terms of single-core performance and memory bandwidth improvements combined with the limited computational resources available in budget-minded cloud computing have highlighted the inefficiencies of language interpreters. To remain relevant in the decades to come, dynamic language VMs must make a concerted effort to reduce overhead and make effective use of performance features made available by the underlying platform. Dynamic optimization through JIT compilation has proven to be an effective mechanism for improving dynamic language performance, but building and maintaining a JIT compiler is an expensive undertaking. Meta-compilation promises to reduce those costs, but incurs other costs that hamper adoption in industry. Through the lens of a company deploying thousands of Ruby projects into production, we assess the limitations of current VMs, highlight the most impactful advancements, and consider what’s most important for the coming decades.


title: Keeping the asm in Wasm: Running High-Level Languages on a Low-Level VM (Invited Talk)

abstract:
WebAssembly (Wasm) is a virtual machine whose defining characteristic is that it is low-level: Wasm is designed to abstract the hardware below, not language concepts above. This is a prerequisite for providing predictable performance and for avoiding language bias without feature creep. At the same time, it is a hard requirement that Wasm is safe and portable, which sometimes necessitates raising its abstraction level above the raw metal. Yet ultimately, the intention is that language runtimes are largely implemented _on top_ of Wasm, in Wasm itself.

Dynamic languages pose a challenge for this model, because achieving acceptable performance for them often requires every dirty trick from the books. Not all of these techniques are easily ported to Wasm with some of its abstractions, or they incur higher cost because a Wasm engine cannot know or trust invariants in the higher-level runtime and may need to perform redundant checks to maintain its own safety. In particular, Wasm will need to supply additional mechanisms to efficiently support techniques like jit compilation or inline caches.


title: The Bright Future of Debuggers: Challenges and Opportunities (Invited Talk)

abstract:
Since the first bug was discovered in the Mark Harvard II electromechanical computer it was clear that finding bugs and debugging of computer systems would be an extremely challenging task. Today, various reports indicated that programmers spend approximately 50% of their time on debugging related tasks resulting in an annual cost of $312 billion. Given these astronomical amounts of resources being put into debugging, any technique that improves debugging efficiency is tremendously valuable.

In the last decades various new debugging techniques have been put forward to ease debugging and finding the root cause of a failures. Techniques like record-replay, deltadebugging, model checking, tracing, visualisation, fuzzing, automated debugging, and many more help programmers to be more effective while debugging. Recently, we have seen that some of techniques are slowly finding their way into mainstream debugging practices. In this talk we first give an overview of recent exiting debugging techniques, show their advantages and limitations to then reflect on the challenges and opportunities for further research.


venue: ecoop

title: Inheritance and Subtyping in a Parallel Object-Oriented Language


title: FORK: A System for Object- and Rule-Oriented Programming

authors:
Clemens Beckstein
Günther Görz
M. Tielemann


title: On Including Part Hierarchies in Object-Oriented Languages with an Implementation in Smalltalk

authors:
Edwin H. Blake
Steve Cook


title: Deltatalk: An Empirically and Aesthetically Motivated Simplification of the Smalltalk-80 Language

authors:
Alan Borning
Tim O'Shea


title: Inheritance and Synchronization in Concurrent OOP

authors:
Jean-Pierre Briot
Akinori Yonezawa


title: The Construction of User Interfaces and the Object Paradigm


title: The Common Lisp Object System: An Overview

authors:
Linda G. DeMichiel
Richard P. Gabriel


title: Object Representation of Scope During Translation


title: On Some Algorithms for Multiple Inheritance in Object-Oriented Programming

authors:
Roland Ducournau
Michel Habib


title: The Filter Browser Defining Interfaces Graphically

authors:
Raimund K. Ege
David Maier


title: Using Types and Inheritance in Object-Oriented Languages

authors:
Daniel C. Halbert
Patrick D. O'Brien


title: Conformance, Genericity, Inheritance and Enhancement


title: Overview of a Parallel Object-Oriented Language CLIX

authors:
Jin Ho Hur
Kilnam Chon


title: A Modeller's Workbench: Experiments in Object-Oriented Simulation


title: Classification of Actions, or Inheritance also for Methods

authors:
Bent Bruun Kristensen
Ole Lehrmann Madsen
Birger Møller-Pedersen
Kristen Nygaard

abstract: The main thing with the sub-class mechanism as found in languages like C++, SIMULA and Smalltalk is its possibility to express specializations. A general class, covering a wide range of objects, may be specialized to cover more specific objects. This is obtained by three properties of sub-classing: An object of a sub-class inherits the attributes of the super-class, virtual procedure/method attributes (of the superclass) may be specialized in the sub-class, and (in SIMULA only) it inherits the actions of the super-class.In the languages mentioned above, virtual procedures/methods of a super-class are specialized in sub-classes in a very primitive manner: they are simply re-defined and need not bear any resemblance of the virtual in the super-class. In BETA, a new object-oriented language, classes and methods are unified into one concept, and by an extension of the virtual concept, virtual procedures/methods in sub-classes are defined as specializations of the virtuals in the super-class. The virtual procedures/methods of the sub-classes thus inherits the attributes (e.g. parameters) and actions from the "super-procedure/method".In the languages mentioned above only procedures/methods may be virtual. As classes and procedures/methods are unified in BETA this gives also virtual classes. The paper demonstrates, how this may be used to parameterize types and enforce constraints on types.


title: Reversible Object-Oriented Interpreters


title: An Object Modelling Technique for Conceptual Design

authors:
Mary E. S. Loomis
Ashwin V. Shah
James E. Rumbaugh


title: Traveler: The Apiary Observatory


title: Behavioral Simulation Based on Knowledge Objects

authors:
Takeo Maruichi
Tetsuya Uchiki
Mario Tokoro


title: Objects as Communicating Prolog Units

authors:
Paola Mello
Antonio Natali


title: Concurrency Features for the Trellis/Owl Language

authors:
J. Eliot B. Moss
Walter H. Kohler


title: The ZOO Metasystem: A Direct-Manipulation Interface to Object-Oriented Knowledge Bases


title: What is "Object-Oriented Programming?"


title: Dynamic Grouping in an Object-Oriented Virtual Memory Hierarchy

authors:
Ifor Williams
Mario Wolczko
Trevor Hopkins


title: Semantics of Smalltalk-80


title: Nesting in an Object-Oriented Language is NOT for the Birds

authors:
Peter A. Buhr
C. Robert Zarnke


title: GSBL: An Algebraic Specification Language Based on Inheritance

authors:
Silvia Clerici
Fernando Orejas


title: An Implementation of an Operating System Kernel Using Concurrent Object-Oriented Language ABCL/c+

authors:
Norihisa Doi
Yasushi Kodama
Ken Hirose


title: An Object-Oriented Exception Handling System for an Object-Oriented Language


title: Asynchronous Data Retrieval from an Object-Oriented Database

authors:
Jonathan P. Gilbert
Lubomir Bic


title: Reflexive Architecture: From ObjVLisp to CLOS


title: The Mjølner Environment: Direct Interaction with Abstractions

authors:
Görel Hedin
Boris Magnusson


title: Debugging Concurrent Systems Based on Object Groups

authors:
Yasuaki Honda
Akinori Yonezawa


title: Name Collision in Multiple Classification Hierarchies

abstract: Supporting multiple classification in object-oriented programming languages is the topic of discussion in this paper. Supporting multiple classification gives rise to one important question -- namely the question of inheritance of attributes with identical names from multiple paths in the classification hierarchy. The problem is to decide how these multiple classification paths are reflected in the class being denned. One of the conclusions in this paper is, that by choosing strict and simple inheritance rules, one is excluding some particular usages of multiple classification. This leads to the notion of attribute-resolution at class definition, which means that the programmer in some cases is forced or allowed to resolve the potential ambiguity of the inherited names. The concept of attribute-resolution is managed through the identification of two conceptually different utilizations of specialization (unification and intersection), and two different attribute properties (plural and singleton) to guide the attribute-resolution.


title: Teaching Object-Oriented Programming Is More than Teaching Object-Oriented Programming Languages

authors:
Jørgen Lindskov Knudsen
Ole Lehrmann Madsen

abstract: One of the important obligations of an expanding research area is to discuss how to approach the teaching of the subject. Without this discussion, we may find that the word is not spread properly, and thus that the results are not properly utilized in industry. Furthermore, discussing teaching the research area gives additional insight into the research area and its underlying theoretical foundation. In this paper we will report on our approach to teaching programming languages as a whole and especially teaching object-oriented programming.The prime message to be told is that working from a theoretical foundation pays off. Without a theoretical foundation, the discussions are often centered around features of different languages. With a foundation, discussions may be conducted on solid ground. Furthermore, the students have significantly fewer difficulties in grasping the concrete programming languages when they have been presented with the theoretical foundation than without it.


title: An Overview of OOPS+, An Object-Oriented Database Programming Language

authors:
Els Laenens
Dirk Vermeir


title: Database Concepts Discussed in Object-Oriented Perspective

authors:
Yngve Lindsjørn
Dag I. K. Sjøberg


title: A Shared, Persistent Object Store


title: What Object-Oriented Programming May Be - and What It Does Not Have To Be

authors:
Ole Lehrmann Madsen
Birger Møller-Pedersen

abstract: A conceptual framework for object-oriented programming is presented. The framework is independent of specific programming language constructs. It is illustrated how this framework is reflected in an object-oriented language and the language mechanisms are compared with the corresponding elements of other object-oriented languages. Main issues of object-oriented programming are considered on the basis of the framework presented here.


title: PCLOS: A Flexible Implementation of CLOS Persistence


title: Implementing Concurrency Control in Reliable Object-Oriented Systems

authors:
Graham D. Parrington
Santosh K. Shrivastava


title: Prototyping an Interactive Electronic Book System Using an Object-Oriented Approach

authors:
Jacques Pasquier-Boltuck
Ed Grossman
Gérald Collaud


title: On the Darker Side of C++


title: The Implementation of a Distributed Smalltalk

authors:
Marcel Schelvis
Eddy Bledoeg


title: Object-Oriented Programming and Computerised Shared Material


title: Fitting Round Objects into Square Databases

authors:
Dennis Tsichritzis
Oscar Nierstrasz


title: SCOOP, Structured Concurrent Object-Oriented Prolog

authors:
Jean G. Vaucher
Guy Lapalme
Jacques Malenfant


title: Inheritance as an Incremental Modification Mechanism or What Like Is and Isn't Like

authors:
Peter Wegner
Stanley B. Zdonik


title: Metalevel Programming in CLOS

authors:
Giuseppe Attardi
Cinzia Bonini
Maria Rosario Boscotrecase
Tito Flagella
Mauro Gaspari


title: Actalk: A Testbed for Classifying and Designing Actor Languages in the Smalltalk-80 Environment


title: A Proposal for Making Eiffel Type-Safe


title: Architecture Models for Interactive Software


title: The Past, Present and Future of Smalltalk


title: The Treatment of Persistent Objects in Arjuna

authors:
Graeme N. Dixon
Graham D. Parrington
Santosh K. Shrivastava
Stuart M. Wheater


title: ObjView: A Task-Oriented, Graphics-Based Tools for Object Visualization and Arrangement

authors:
Gerhard Friedrich
Wolfgang Höllinger
Christian Stary
Markus Stumptner


title: Integration of a Programming Environment into ET++ - A Case Study

authors:
Erich Gamma
André Weinand
Rudolph Marty


title: An Object-Oriented Notation for Attribute Grammars


title: Inheritance in Actor Based Concurrent Object-Oriented Languages

authors:
Dennis G. Kafura
Keung Hae Lee


title: Objects - A Fresh Look


title: MELDing Multiple Granularities of Parallelism

authors:
Gail E. Kaiser
Steven S. Popovich
Wenwey Hseush
Shyhtsun Felix Wu


title: A Customizable Window-Interface to Object-Oriented Databases

authors:
Els Laenens
François Staes
Dirk Vermeir


title: A Class Hierarchy for Building Stream-Oriented File Systems

authors:
Peter Madany
Roy H. Campbell
Vincent F. Russo
Douglas E. Leyens


title: ObjVProlog: Metaclasses in Logic

authors:
Jacques Malenfant
Guy Lapalme
Jean G. Vaucher


title: Four Steps and a Rest in Putting an Object-Oriented Programming Environment to Practical Use

authors:
Gerhard Müller
Anna-Kristin Pröfrock


title: A Design Method for Object-Oriented Programming

authors:
Winnie W. Y. Pun
Russel L. Winder


title: A Compositional Model for Software Reuse

authors:
Rajendra K. Raj
Henry M. Levy


title: Disciplined Inheritance


title: Persistence and Migration for C++ Objects

authors:
Marc Shapiro
Philippe Gautron
Laurence Mosseri


title: Problems in Object-Oriented Software Reuse

authors:
David H. Taenzer
Murthy Ganti
Sunil Podar


title: First Steps Towards Fully Abstract Semantics for Object-Oriented Languages


title: A Reflective Architecture for an Object-Oriented Distributed Operating System

authors:
Yasuhiko Yokote
Fumio Teraoka
Mario Tokoro


title: OOZE: An Object Oriented Z Environment

authors:
Antonio J. Alencar
Joseph A. Goguen


title: Issues in the Design and Implementation of a Schema Designer for an OODBMS


title: Schema Modifications in the LISPO2 Persistent Object-Oriented Language


title: Incremental Class Dictionary Learning and Optimization

authors:
Paul L. Bergstein
Karl J. Lieberherr


title: Object-Oriented Analysis and Top-Down Software Development


title: Definition of Reusable Concurrent Software Components

authors:
Stefano Crespi Reghizzi
Guido Galli de Paratesi
Stefano Genolini


title: Inheritance in Object-Oriented Z


title: The Design of an Integrity Consistency Checker (ICC) for an Object-Oriented Database System

authors:
Christine Delcourt
Roberto V. Zicari


title: Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches

authors:
Urs Hölzle
Craig Chambers
David M. Ungar


title: An Object Calculus for Asynchronous Communication

authors:
Kohei Honda
Mario Tokoro


title: Exceptions in Guide, an Object-Oriented Language for Distributed Applications


title: Implementation Techniques for Integral Version Management

authors:
Ernst Lippe
Gert Florijn


title: Hybrid Group Reflective Architecture for Object-Oriented Concurrent Reflective Programming

authors:
Satoshi Matsuoka
Takuo Watanabe
Akinori Yonezawa


title: Object Integrity Using Rules

authors:
Claudia Bauzer Medeiros
Patrick Pfeffer


title: An Object-Oriented Logic Language for Modular System Specification

authors:
Angelo Morzenti
Pierluigi San Pietro


title: Multi-Methods in a Statically-Typed Programming Language

authors:
Warwick B. Mugridge
John Hamer
John G. Hosking


title: Synchronizing Actions


title: What is Type-Safe Code Reuse?

authors:
Jens Palsberg
Michael I. Schwartzbach

abstract: Subclassing is reuse of class definitions. It is usually tied to the use of class names, thus relying on the order in which the particular classes in a program are created. This is a burden, however, both when programming and in theoretical studies.


title: Implementational Reflection in Silica


title: Modeling the C++ Object Model, An Application of an Abstract Object Model


title: Capsules and Types in Fresco: Program Verification in Smalltalk


title: Representation of Complex Objects: Multiple Facets with Part-Whole Hierarchies

authors:
Francis Wolinski
Jean-François Perrot


title: An Object-Oriented Language-Database Integration Model: The Composition-Filters Approach

authors:
Mehmet Aksit
Lodewijk Bergmans
Sinan Vural


title: Supporting Physical Independence in an Object Database Server

authors:
Nicola Aloia
Svetlana Barneva
Fausto Rabitti


title: System Design by Composing Structures of Interacting Objects

authors:
Egil P. Andersen
Trygve Reenskaug


title: An Incremental Class Reorganization Approach


title: Object-Oriented Multi-Methods in Cecil


title: ACTS: A Type System for Object-Oriented Programming Based on Abstract and Concrete Classes

authors:
Mahesh H. Dodani
Chung-Shin Tsai


title: Integrating Constraints with an Object-Oriented Language

authors:
Bjørn N. Freeman-Benson
Alan Borning


title: Inheritance of Synchronization Constraints in Concurrent Object-Oriented Programming Languages


title: Using Object-Oriented Programming Techniques for Implementing ISDN Supplementary Services


title: Nesting Actions through Asynchronous Message Passing: the ACS Protocol

authors:
Rachid Guerraoui
Riccardo Capobianchi
Agnes Lanusse
Pierre Roux


title: Aggregation in a Behaviour Oriented Object Model

authors:
Thorsten Hartmann
Ralf Jungclaus
Gunter Saake


title: Specifying Reusable Components Using Contracts


title: A Reflective Model of Inheritance

authors:
Suresh Jagannathan
Gul Agha


title: EPEE: an Eiffel Environment to Program Distributed Memory Parallel Computers


title: On Unifying Relational and Object-Oriented Database Systems


title: Reasoning and Refinement in Object-Oriented Specification Languages

authors:
Kevin Lano
Howard P. Haughton


title: An Object-Oriented Class Library for Scalable Parallel Heuristic Search

authors:
Wing Cheong Lau
Vineet Singh


title: Developing a Class Hierarchy for Object-Oriented Transaction Processing


title: An Object Model for Engineering Design

authors:
Gia Toan Nguyen
Dominique Rieu
José Escamilla


title: Unifying the Design and Implementation of User Interfaces through the Object Paradigm

authors:
Véronique Normand
Joëlle Coutaz


title: Making Type Inference Practical

authors:
Nicholas Oxhøj
Jens Palsberg
Michael I. Schwartzbach

abstract: We present the implementation of a type inference algorithm for untyped object-oriented programs with inheritance, assignments, and late binding. The algorithm significantly improves our previous one, presented at OOPSLA'91, since it can handle collection classes, such as List, in a useful way. Abo, the complexity has been dramatically improved, from exponential time to low polynomial time. The implementation uses the techniques of incremental graph construction and constraint template instantiation to avoid representing intermediate results, doing superfluous work, and recomputing type information. Experiments indicate that the implementation type checks as much as 100 lines pr. second. This results in a mature product, on which a number of tools can be based, for example a safety tool, an image compression tool, a code optimization tool, and an annotation tool. This may make type inference for object-oriented languages practical.


title: Import is Not Inheritance - Why We Need Both: Modules and Classes


title: Combining Object-Oriented and Logic Paradigms: A Modal Logic Programming Approach


title: Implementation of Distributed Trellis


title: Type Inference of SELF

authors:
Ole Agesen
Jens Palsberg
Michael I. Schwartzbach


title: The OSI Managed-Object Model


title: PANDA - Supporting Distributed Programming in C++

authors:
Holger Assenmacher
Thomas Breitbach
Peter Buhler
Volker Hübsch
Reinhard Schwarz


title: Typed Sets as a Basis for Object-Oriented Database Schemas

authors:
Herman Balsters
Rolf A. de By
Roberto V. Zicari


title: Panel: Aims, Means, and Future of Object-Oriented Languages

authors:
Mike Banahan
L. Peter Deutsch
Boris Magnusson
Jens Palsberg


title: Frameworks in the Financial Engineering Domain - An Experience Report

authors:
Andreas Birrer
Thomas Eggenschwiler


title: Encapsulating Plurality

authors:
Andrew P. Black
Mark P. Immel


title: Attaching Second-Order Types to Methods in an Object-Oriented Language

authors:
Yves Caseau
Laurent Perron


title: Predicate Classes


title: Designing an Extensible Distributed Language with a Meta-Level Architecture

authors:
Shigeru Chiba
Takashi Masuda


title: O-O Requirements Analysis: an Agent Perspective

authors:
Eric Dubois
Philippe Du Bois
Michaël Petit


title: A Language Framework for Multi-Object Coordination

authors:
Svend Frølund
Gul Agha


title: Design Patterns: Abstraction and Reuse of Object-Oriented Design

authors:
Erich Gamma
Richard Helm
Ralph E. Johnson
John M. Vlissides


title: ObjChart: Tangible Specification of Reactive Object Behavior

authors:
Dipayan Gangopadhyay
Subrata Mitra


title: Integrating Independently-Developed Components in Object-Oriented Languages


title: Transparent Parallelisation Through Reuse: Between a Compiler and a Library Approach


title: MetaFlex: A Flexible Metaclass Generator

authors:
Richard Johnson
Murugappan Palaniappan


title: Object Oriented Interoperability

abstract: Object Oriented Interoperability is an extension and generalization of the Procedure Oriented Interoperability approaches taken in the past. It provides an interoperability support frame by considering the object as the basic interoperation unit. This way interoperation is based on higher level abstractions and it is independent of the specific interface through which a service is used. A prototype implementation demonstrates both the feasibility of the ideas and the related implementation issues.


title: Intimate Computing and the Memory Prothesis: A Challenge for Computer Systems Research? (Abstract)


title: A New Definition of the Subtype Relation

authors:
Barbara Liskov
Jeannette M. Wing


title: Solving the Inheritance Anomaly in Concurrent Object-Oriented Programming


title: TOOA: A Temporal Object-Oriented Algebra

authors:
Ellen Rose
Arie Segev


title: Active Programming Strategies in Reuse

authors:
Mary Beth Rosson
John M. Carroll


title: A Timed Calculus for Distributed Objects with Clocks

authors:
Ichiro Satoh
Mario Tokoro


title: Nested Mixin-Methods in Agora

authors:
Patrick Steyaert
Wim Codenie
Theo D'Hondt
Koen De Hondt
Carine Lucas
Marc Van Limberghen


title: Real-Time Specification Inheritance Anomalies and Real-Time Filters

authors:
Mehmet Aksit
Jan Bosch
William van der Sterren
Lodewijk Bergmans


title: Declarative Object-Oriented Programming: Inheritance, Subtyping and Prototyping

authors:
Suad Alagic
Rajshekhar Sunderraman
Rajiv Bagai


title: Customising Object Allocation

authors:
Giuseppe Attardi
Tito Flagella


title: Patterns Generate Architectures

authors:
Kent L. Beck
Ralph E. Johnson


title: Deductive Object Databases

authors:
Elisa Bertino
Giovanna Guerrini
Danilo Montesi


title: A Specification Language for Object-Oriented Analysis and Design

authors:
Ted L. Briggs
John Werth


title: A Geographic Environmental Modeling System: Towards an Object-Oriented Framework

authors:
Bernd Bruegge
Erik Riedel


title: Efficient Dynamic Look-Up Strategy for Multi-Methods

authors:
Weimin Chen
Volker Turau
Wolfgang Klas


title: Adding Digital Video to an Object-Oriented User Interface Toolkit

authors:
Stephen Martin Guy Freeman
Mark S. Manasse


title: Atomic Object Composition


title: Protection in the Guide Object-Oriented Distributed System


title: Should Superclasses be Abstract?


title: Methods as Assertions

authors:
John Lamping
Martín Abadi


title: Abstracting Process-to-Function Relations in Concurrency Object-Oriented Applications

authors:
Cristina Videira Lopes
Karl J. Lieberherr


title: Constraints and Object Identity

authors:
Gus Lopez
Bjørn N. Freeman-Benson
Alan Borning


title: Combining Object-Oriented Analysis and Formal Description Techniques

authors:
Ana M. D. Moreira
Robert G. Clark


title: Generalizing Dispatching in a Distributed Object System

authors:
Farshad Nayeri
Benjamin Hurwitz
Frank Manola


title: Object Location Control Using Meta-level Programming

authors:
Hideaki Okamura
Yutaka Ishikawa


title: Object-Oriented Computations in Logic Programming

authors:
Andrea Omicini
Antonio Natali


title: Modeling Object-Oriented Program Execution

authors:
Wim De Pauw
Doug Kimelman
John M. Vlissides


title: Product Configurations - An Application for Prototype Object Approach

authors:
Hannu Peltonen
Tomi Männistö
Kari Alho
Reijo Sulonen


title: Meta Patterns - A Means For Capturing the Essentials of Reusable Object-Oriented Design


title: Beyond Objects


title: Putting Objects to Work: Hypermedia as the Subject Matter and the Medium for Computer-Supported Cooperative Work


title: Typed Concurrent Objects


title: Taming Message Passing: Efficient Method Look-Up for Dynamically Typed Languages

authors:
Jan Vitek
R. Nigel Horspool


title: Roles and Dynamic Subclasses: A Modal Logic Approach

authors:
Roel J. Wieringa
Wiebren de Jonge
Paul Spruit


title: On Subtyping and Matching

authors:
Martín Abadi
Luca Cardelli


title: The Cartesian Product Algorithm: Simple and Precise Type Inference Of Parametric Polymorphism


title: ChyPro: A Hypermedia Programming Environment for Smalltalk-80


title: An Object-Oriented Framework for the Formal Verification of Processors

authors:
Laurent Arditi
Hélène Collavizza


title: Objects with Multiple Most Specific Classes

authors:
Elisa Bertino
Giovanna Guerrini


title: PolyTOIL: A Type-Safe Polymorphic Object-Oriented Language

authors:
Kim B. Bruce
Angela Schuett
Robert van Gent


title: Optimization of Object-Oriented Programs Using Static Class Hierarchy Analysis

authors:
Jeffrey Dean
David Grove
Craig Chambers


title: Message Dispatch on Pipelined Processors

authors:
Karel Driesen
Urs Hölzle
Jan Vitek


title: Object Protocols as Functional Parsers


title: Do Object-Oriented Languages Need Special Hardware Support?

authors:
Urs Hölzle
David M. Ungar


title: Sharing Properties in a Uniform Object Space

authors:
Heiko Kießling
Uwe Krüger


title: Interface-Based Protocol Specification of Open Systems using PSL

authors:
Doug Lea
Jos Marlowe


title: Meta-level Programming with CodA


title: Time and Asynchrony in Interactions among Distributed Real-Time Objects

authors:
Ichiro Satoh
Mario Tokoro


title: Experience Using Design Patterns to Evolve Communication Software Across Diverse OS Platforms

authors:
Douglas C. Schmidt
Paul Stephenson


title: Incremental Mature Garbage Collection Using the Train Algorithm

authors:
Jacob Seligmann
Steffen Grarup


title: Programming as an Experience: The Inspiration for Self

authors:
Randall B. Smith
David M. Ungar


title: A Marriage of Class- and Object-Based inheritance Without Unwanted Children

authors:
Patrick Steyaert
Wolfgang De Meuter


title: Using Metaobject Protocols to Implement Atomic Data Types

authors:
Robert J. Stroud
Zhixue Wu


title: Object Imaging


title: Experiences on The Road to Object Utopia (Abstract)


title: Eliminating Virtual Function Calls in C++ Programs

authors:
Gerald Aigner
Urs Hölzle


title: Supporting Explicit Disambiguation of Multi-Methods

authors:
Eric Amiel
Eric Dujardin


title: An Application Framework For Module Composition Tools

authors:
Guruduth Banavar
Gary Lindstrom


title: Will Europe ever Produce and sell Objects?


title: Large Scale Object-Oriented Software-Development in a Banking Environment: An Experience Report

authors:
Dirk Bäumer
Rolf Knoll
Guido Gryczan
Heinz Züllighoven


title: Type-Safe Compilation of Covariant Specialization: A Practical Case

authors:
John Boyland
Giuseppe Castagna


title: Generalising the BETA Type System

authors:
Søren Brandt
Jørgen Lindskov Knudsen


title: Dynamic Clustering in Object Databases Exploiting Effective Use of Relationships Between Objects

authors:
Frédérique Bullat
Michel Schneider


title: Automatic Generation of User Interfaces From Data Structure Specifications and Object-Oriented Application Models

authors:
Vadim Engelson
Dag Fritzson
Peter Fritzson


title: Protocol Classes for Designing Reliable Distributed Environments

authors:
Benoît Garbinato
Pascal Felber
Rachid Guerraoui


title: Integrating Subtyping, Matching and Type Quantification: A Practical Perspective

authors:
Andreas Gawecki
Florian Matthes


title: Measurement Strategies


title: Bridging the Gap Between C++ and Relational Databases


title: Inheritance and Cofree Constructions


title: Parallel Operators

authors:
Jean-Marc Jézéquel
Jean-Lin Pacherie


title: An Implementation Method of Migratable Distributed Objects Using an RPC Technique Integrated with Virtual Memory Management

authors:
Kenji Kono
Kazuhiko Kato
Takashi Masuda


title: Activities: Abstractions for Collective Behavior

authors:
Bent Bruun Kristensen
Daniel C. M. May


title: (Objects + Concurrency) & Reusability - A Proposal to Circumvent the Inheritance Anomaly

authors:
Ulrike Lechner
Christian Lengauer
Friederike Nickl
Martin Wirsing


title: Towards Alias-Free Pointers


title: Typed Object-Oriented Functional Programming with Late Binding

authors:
Zhenyu Qian
Bernd Krieg-Brückner


title: Metaphoric Polymorphism: Taking Code Reuse One Step Further

authors:
Ran Rinat
Menachem Magidor


title: Modeling Subobject-based Inheritance

authors:
Jonathan G. Rossie Jr.
Daniel P. Friedman
Mitchell Wand


title: Conceptual Design of Active Object-Oriented Database Applications Using Multi-level Diagrams

authors:
Mauricio J. V. Silva
C. Robert Carlson


title: Balloon Types: Controlling Sharing of State in Data Types


title: Static Integrity Constraint Management in Object-Oriented Database Programming Languages via Predicate Transformers

authors:
Véronique Benzaken
Xavier Schaefer


title: Objects, Associations and Subsystems: A Hierarchical Approach to Encapsulation

authors:
Juan Bicarregui
Kevin Lano
T. S. E. Maibaum


title: Towards a Formalization of the Unified Modeling Language

authors:
Ruth Breu
Ursula Hinkel
Christoph Hofmann
Cornel Klein
Barbara Paech
Bernhard Rumpe
Veronika Thurner

abstract: The Unified Modeling Language UML is a language for specifying, visualizing and documenting object-oriented systems. UML combines the concepts of OOA/OOD, OMT and OOSE and is intended as a standard in the domain of object-oriented analysis and design. Due to the missing formal, mathematical foundation of UML the syntax and the semantics of a number of UML constructs are not precisely defined. This paper outlines a proposal for the formal foundation of UML that is based on a mathematical system model.


title: Subtyping Is Not a Good "Match" for Object-Oriented Languages

authors:
Kim B. Bruce
Leaf Petersen
Adrian Fiech


title: Java is Type Safe - Probably

authors:
Sophia Drossopoulou
Susan Eisenbach


title: DRASTIC: A Run-Time Architecture for Evolving, Distributed, Persistent Systems

authors:
James Huw Evans
Peter Dickman


title: Tool Support for Object-Oriented Patterns

authors:
Gert Florijn
Marco Meijers
Pieter van Winsen


title: Going Beyond Objects with Design Patterns (Abstract)


title: A General Framework for Inheritance Management and Method Dispatch in Object-Oriented Languages

authors:
Wade Holst
Duane Szafron


title: Aspect-Oriented Programming

authors:
Gregor Kiczales
John Lamping
Anurag Mendhekar
Chris Maeda
Cristina Videira Lopes
Jean-Marc Loingtier
John Irwin


title: Near Optimal Hierarchical Encoding of Types

authors:
Andreas Krall
Jan Vitek
R. Nigel Horspool


title: An Extended Theory of Primitive Objects: FIrst Order System


title: A Reflective Architecture for Process Control Applications


title: A Model for Structuring User Documentation of Object-Oriented Frameworks Using Patterns and Hypertext

authors:
Matthias Meusel
Krzysztof Czarnecki
Wolfgang Köpf


title: Dynamic Object Evolution without Name Collisions


title: Issues with Exception Handling in Object-Oriented Systems

authors:
Robert Miller
Anand R. Tripathi


title: GOODS to Appear on the Stage


title: Using Patterns for Design and Documentation

authors:
Georg Odenthal
Klaus Quibeldey-Cirkel


title: Optimizing Smalltalk by Selector Code INdexing Can Be Practical

authors:
Tamiya Onodera
Hiroaki Nakamura


title: Feature-Oriented Programming: A Fresh Look at Objects


title: Coordination Requirements Expressed in Types for Active Objects


title: Genericity in Java with Virtual Types


title: Orthogonal to the Java Imperative

authors:
Suad Alagic
Jose Solorzano
David Gitchell


title: Providing Orthogonal Persistence for Java (Extended Abstract)

authors:
Malcolm P. Atkinson
Mick J. Jordan


title: Extending the ODMG Object Model with Time

authors:
Elisa Bertino
Elena Ferrari
Giovanna Guerrini
Isabella Merlo


title: An Imperative, First-Order Calculus with Object Extension

authors:
Viviana Bono
Kathleen Fisher


title: Wrappers to the Rescue

authors:
John Brant
Brian Foote
Ralph E. Johnson
Don Roberts


title: A Statically Safe Alternative to Virtual Types

authors:
Kim B. Bruce
Martin Odersky
Philip Wadler


title: The M.A.D. Experience: Multiperspective Application Development in evolutionary prototyping

authors:
Michael Christensen
Andy Crabtree
Christian Heide Damm
Klaus Marius Hansen
Ole Lehrmann Madsen
Pernille Marqvardsen
Preben Mogensen
Elmer Sandvad
Lennert Sloth
Michael Thomsen


title: Experiences Developing a Virtual Shared Memory System Using High-Level Object Paradigms

authors:
Jörg Cordsen
Jörg Nolte
Wolfgang Schröder-Preikschat


title: Classifying Inheritance Mechanisms in Concurrent Object Oriented Programming

authors:
Lobel Crnogorac
Anand S. Rao
Kotagiri Ramamohanarao


title: Predicate Dispatching: A Unified Theory of Dispatch

authors:
Michael D. Ernst
Craig S. Kaplan
Craig Chambers


title: Modelling a Distributed Cached Store for Garbage Collection: The Algorithm and Its Correctness Proof

authors:
Paulo Ferreira
Marc Shapiro


title: Modelica - A Unified Object-Oriented Language for System Modelling and Simulation

authors:
Peter Fritzson
Vadim Engelson


title: The Complexity of Type Analysis of Object Oriented Programs

authors:
Joseph Gil
Alon Itai


title: Reflection for Statically Typed Languages


title: Binary Component Adaptation

authors:
Ralph Keller
Urs Hölzle


title: Synthesizing Object-Oriented and Functional Design to Promote Re-Use

authors:
Shriram Krishnamurthi
Matthias Felleisen
Daniel P. Friedman


title: Mobile Objects and Mobile Agents: The Future of Distributed Computing?


title: Precise Visual Specification of Design Patterns

authors:
Anthony Lauder
Stuart Kent


title: On Object Extension


title: Design and Partial Evaluation of Meta-Objects for a Concurrent Reflective Language

authors:
Hidehiko Masuhara
Akinori Yonezawa


title: A Study of The Fragile Base Class Problem

authors:
Leonid Mikhajlov
Emil Sekerinski


title: Flexible Alias Protection

authors:
James Noble
Jan Vitek
John Potter


title: Cyclic Distributed Garbage Collection with Group Merger

authors:
Helena Rodrigues
Richard E. Jones


title: Framework Design for End-to-End Optimization

authors:
Aamod Sane
Ashish Singhai
Roy H. Campbell


title: Implementing Layered Designs with Mixin Layers

authors:
Yannis Smaragdakis
Don S. Batory


title: Object-Oriented Architectural Support for a Java Processor

authors:
Narayanan Vijaykrishnan
N. Ranganathan
Ravi Gadekarla


title: Formal Specification and Prototyping of CORBA Systems

authors:
Rémi Bastide
Ousmane Sy
Philippe A. Palanque


title: An Approach to Classify Semi-structured Objects

authors:
Elisa Bertino
Giovanna Guerrini
Isabella Merlo
Marco Mesiti


title: Object-Oriented Programming: Regaining the Excitement


title: A Core Calculus of Classes and Mixins

authors:
Viviana Bono
Amit Patel
Vitaly Shmatikov


title: Synthesizing Objects

authors:
Krzysztof Czarnecki
Ulrich W. Eisenecker


title: Inlining of Virtual Methods

authors:
David Detlefs
Ole Agesen


title: A Study of the Allocation Behavior of the SPECjvm98 Java Benchmark

authors:
Sylvia Dieckmann
Urs Hölzle


title: Propagating Class and Method Combination


title: Process Algebraic Specification of the New Asynchronous CORBA Messaging Service

authors:
Mauro Gaspari
Gianluigi Zavattaro


title: An Object-Oriented Effects System

authors:
Aaron Greenhouse
John Boyland


title: A Trace Model for Pointers and Objects

authors:
C. A. R. Hoare
Jifeng He


title: Foundations for Virtual Types

authors:
Atsushi Igarashi
Benjamin C. Pierce


title: Type-Safe Delegation for Run-Time Component Adaptation


title: Internal Iteration Externalized


title: Dynamic Query-Based Debugging

authors:
Raimondas Lencevicius
Urs Hölzle
Ambuj K. Singh


title: Providing Persistent Objects in Distributed Systems

authors:
Barbara Liskov
Miguel Castro
Liuba Shrira
Atul Adya


title: Modular Statically Typed Multimethods

authors:
Todd D. Millstein
Craig Chambers


title: Providing Fine-grained Access Control for Java Programs

authors:
Raju Pandey
Brant Hashii


title: Multi-method Dispatch Using Multiple Row Displacement

authors:
Candy Pang
Wade Holst
Yuri Leontiev
Duane Szafron


title: Visualizing Reference Patterns for Solving Memory Leaks in Java

authors:
Wim De Pauw
Gary Sevitsky


title: Towards Automatic Specialization of Java Programs

authors:
Ulrik Pagh Schultz
Julia L. Lawall
Charles Consel
Gilles Muller


title: Wide Classes


title: Unifying Genericity - Combining the Benefits of Virtual Types and Parameterized Classes

authors:
Kresten Krab Thorup
Mads Torgersen


title: Object-Oriented Programming on the Network


title: Jam - A Smooth Extension of Java with Mixins

authors:
Davide Ancona
Giovanni Lagorio
Elena Zucca


title: Generic Wrappers

authors:
Martin Büchi
Wolfgang Weck


title: Load-Time Structural Reflection in Java


title: Using Objects for Next Generation Communication Services


title: Creative Object-Oriented Modelling: Support for Intuition, Flexibility, and Collaboration in CASE Tools

authors:
Christian Heide Damm
Klaus Marius Hansen
Michael Thomsen
Michael Tyrsted


title: Ionic Types

authors:
Simon A. Dobson
Brian Matthews


title: A Mixin-Based, Semantics-Based Approach to Reusing Domain-Specific Programming Languages


title: Empirical Study of Object-Layout Strategies and Optimization Techniques

authors:
Natalie Eckel
Joseph Gil


title: Distributed Asynchronous Collections: Abstractions for Publish/Subscribe Interaction

authors:
Patrick Th. Eugster
Rachid Guerraoui
Joe Sventek


title: Extending Moby with Inheritance-Based Subtyping

authors:
Kathleen Fisher
John H. Reppy


title: UML-F: A Modeling Language for Object-Oriented Frameworks

authors:
Marcus Fontoura
Wolfgang Pree
Bernhard Rumpe

abstract: The paper presents the essential features of a new member of the UML language family that supports working with object-oriented frameworks. This UML extension, called UML-F, allows the explicit representation of framework variation points. The paper discusses some of the relevant aspects of UML-F, which is based on standard UML extension mechanisms. A case study shows how it can be used to assist framework development. A discussion of additional tools for automating framework implementation and instantiation rounds out the paper.


title: Automated Test Case Generation from Dynamic Models

authors:
Peter Fröhlich
Johannes Link


title: Developing Security Systems in the Real World


title: Copying and Comparing: Problems and Solutions

authors:
Peter Grogono
Markku Sakkinen


title: Optimizing Java Programs in the Presence of Exceptions

authors:
Manish Gupta
Jong-Deok Choi
Michael Hind


title: On Inner Classes

authors:
Atsushi Igarashi
Benjamin C. Pierce


title: Design Templates for Collective Behavior

authors:
Pertti Kellomäki
Tommi Mikkonen


title: Towards a Unified Programming Language


title: Runtime Support for Type-Safe Dynamic Java Classes

authors:
Scott Malabarba
Raju Pandey
Jeff Gragg
Earl T. Barr
J. Fritz Barnes


title: OpenJIT: An Open-Ended, Reflective JIT Compiler Framework for Java

authors:
Hirotaka Ogawa
Kouya Shimura
Satoshi Matsuoka
Fuyuhiko Maruyama
Yukihiko Sohda
Yasunori Kimura


title: HERCULE : Non-invasively Tracking JavaTM Component-Based Application Activity


title: A Basic Model of Typed Components

authors:
João Costa Seco
Luís Caires


title: Design Patterns Application in UML

authors:
Gerson Sunyé
Alain Le Guennec
Jean-Marc Jézéquel


title: True Modules for Java-like Languages

authors:
Davide Ancona
Elena Zucca


title: Quality and Understandability of Use Case Models

authors:
Bente Anda
Dag I. K. Sjøberg
Magne Jørgensen


title: Concurrent Cycle Collection in Reference Counted Systems

authors:
David F. Bacon
V. T. Rajan


title: Sealing, Encapsulation, and Mutability

authors:
Marina Biberstein
Joseph Gil
Sara Porat


title: Capabilities for Sharing: A Generalisation of Uniqueness and Read-Only

authors:
John Boyland
James Noble
William Retert


title: Reflections on MOPs, Components, and Java Security

authors:
Denis Caromel
Julien Vayssière


title: Simple Ownership Types for Object Containment

authors:
David G. Clarke
James Noble
John Potter


title: People and the Limits of Methodology


title: Fickle : Dynamic Object Re-classification

authors:
Sophia Drossopoulou
Ferruccio Damiani
Mariangiola Dezani-Ciancaglini
Paola Giannini


title: Family Polymorphism


title: Selecting an Efficient OO Integration Testing Strategy: An Experimental Comparison of Actual Strategies

authors:
Vu Le Hanh
Kamel Akif
Yves Le Traon
Jean-Marc Jézéquel


title: CCC: User-Defined Object Structure in C

authors:
Yasunori Harada
Kenichi Yamazaki
Richard Potter


title: On the Usefulness of Liveness for Garbage Collection and Leak Detection

authors:
Martin Hirzel
Amer Diwan
Antony L. Hosking


title: An Overview of AspectJ

authors:
Gregor Kiczales
Erik Hilsdale
Jim Hugunin
Mik Kersten
Jeffrey Palm
William G. Griswold


title: Scripting .NET Using Mondrian

authors:
Erik Meijer
Nigel Perry
Arjan van Yzendoorn


title: Distinctness and Sharing Domains for Static Analysis of Java Programs

authors:
Isabelle Pollet
Baudouin Le Charlier
Agostino Cortesi


title: A Quasi Optimal Bit-Vector Encoding of Tree Hierarchies. Application to Efficient Type Inclusion Tests

authors:
Olivier Raynaud
Eric Thierry


title: Language, Objects, and Intentionality


title: The Optimistic Readers Transformation

authors:
Robert E. Strom
Joshua S. Auerbach


title: A Bytecode Translator for Distributed Execution of "Legacy" Java Software

authors:
Michiaki Tatsubori
Toshiyuki Sasaki
Shigeru Chiba
Kozo Itano


title: Precise Constraint-Based Type Inference for Java

authors:
Tiejun Wang
Scott F. Smith


title: Behavioral Compatibility of Self-Typed Theories

authors:
Suad Alagic
Svetlana Kouznetsova


title: Architectural Reasoning in ArchJava

authors:
Jonathan Aldrich
Craig Chambers
David Notkin


title: A Formal Framework for Java Separate Compilation

authors:
Davide Ancona
Giovanni Lagorio
Elena Zucca


title: Thin Guards: A Simple and Effective Technique for Reducing the Penalty of Dynamic Class Loading

authors:
Matthew Arnold
Barbara G. Ryder


title: Space- and Time-Efficient Implementation of the Java Object Model

authors:
David F. Bacon
Stephen J. Fink
David Grove


title: Modern Concurrency Abstractions for C#

authors:
Nick Benton
Luca Cardelli
Cédric Fournet


title: Lana: An Approach to Programming Autonomous Systems

authors:
Ciarán Bryce
Chrislain Razafimahefa
Michel Pawlak


title: A Simple and Practical Approach to Unit Testing: The JML and JUnit Way

authors:
Yoonsik Cheon
Gary T. Leavens


title: Code Sharing among Virtual Machines

authors:
Grzegorz Czajkowski
Laurent Daynès
Nathaniel Nystrom


title: Engineering Event-Based Systems with Scopes

authors:
Ludger Fiege
Mira Mezini
Gero Mühl
Alejandro P. Buchmann


title: Polychotomic Encoding: A Better Quasi-Optimal Bit-Vector Encoding of Tree Hierarchies


title: Type-Safe Method Inlining

authors:
Neal Glew
Jens Palsberg


title: Atomic Instructions in Java

authors:
David Hovemeyer
William W. Pugh
Jaime Spacco


title: Difference-Based Modules: A Class-Independent Module Mechanism

authors:
Yuuji Ichisugi
Akira Tanaka


title: On Variance-Based Subtyping for Parametric Types

authors:
Atsushi Igarashi
Mirko Viroli


title: AOP: Does It Make Sense? The Case of Concurrency and Failures

authors:
Jörg Kienzle
Rachid Guerraoui

abstract: Concurrency and failures are fundamental problems in distributed computing. One likes to think that the mechanisms needed to address these problems can be separated from the rest of the distributed application: in modern words, these mechanisms could be aspectized. Does this however make sense?This paper relates an experience that conveys our initial and indeed biased intuition that the answer is in general no. Except for simple academic examples, it is hard and even potentially dangerous to separate concurrency control and failure management from the actual application.We point out the very facts that (1) an aspect-oriented language can, pretty much like a macro language, be beneficial for code factorization (but should be reserved to experienced programmers), and (2) concurrency and failures are particularly hard to aspectize because they are usually part of the phenomenon that objects should simulate. They are in this sense different than other concerns, like for instance tracing, which might be easier to aspectize.


title: Semantic Models for Distributed Object Reflection

authors:
José Meseguer
Carolyn L. Talcott


title: Pattern-Based Design and Implementation of an XML and RDF Parser and Interpreter: A Case Study

authors:
Gustaf Neumann
Uwe Zdun


title: Patterns as Signs

authors:
James Noble
Robert Biddle


title: Dynamically Composable Collaborations with Delegation Layers


title: Supporting Unanticipated Dynamic Adaptation of Application Behaviour

authors:
Barry Redmond
Vinny Cahill


title: Modular Internet Programming with Cells

authors:
Ran Rinat
Scott F. Smith


title: Semantics-Based Composition of Class Hierarchies

authors:
Gregor Snelting
Frank Tip


title: Objectively: Components versus Web Services


title: J-Orchestra: Automatic Java Application Partitioning

authors:
Eli Tilevich
Yannis Smaragdakis


title: Type-Safe Prototype-Based Component Evolution

abstract: Component-based programming is currently carried out using mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the programming language level. We propose a simple prototype-based model for first-class components on top of a class-based object-oriented language. The model is formalized as an extension of Featherweight Java. Our calculus includes a minimal set of primitives to dynamically build, extend, and compose software components, while supporting features like explicit context dependencies, late composition, unanticipated component extensibility, and strong encapsulation. We present a type system for our calculus that ensures type-safe component definition, composition, and evolution.


title: Built-in Object Security


title: Language Support for Connector Abstractions

authors:
Jonathan Aldrich
Vibha Sazawal
Craig Chambers
David Notkin


title: A Refinement Algebra for Object-Oriented Programming

authors:
Paulo Borba
Augusto Sampaio
Márcio Cornélio


title: External Uniqueness Is Unique Enough

authors:
Dave Clarke
Tobias Wrigstad


title: Object-Oriented Reading Techniques for Inspection of UML Models - An Industrial Experiment

authors:
Reidar Conradi
Parastoo Mohagheghi
Tayyaba Arif
Lars Christian Hegde
Geir Arne Bunde
Anders Pedersen


title: Higher-Order Hierarchies


title: Growing XQuery

authors:
Mary F. Fernández
Jérôme Siméon


title: Regular Object Types

authors:
Vladimir Gapeyev
Benjamin C. Pierce


title: Walkabout Revisited: The Runabout


title: Open APIs for Embedded Security


title: Discovering Algebraic Specifications from Java Classes

authors:
Johannes Henkel
Amer Diwan


title: A Calculus of Untyped Aspect-Oriented Programs

authors:
Radha Jagadeesan
Alan Jeffrey
James Riely


title: A Type System and Analysis for the Automatic Extraction and Enforcement of Design Information

authors:
Patrick Lam
Martin C. Rinard

abstract: We present a new type system and associated type checker, analysis, and model extraction algorithms for automatically extracting models that capture aspects of a program’s design. Our type system enables the developer to place a token on each object; this token serves as the object’s representative during the analysis and model extraction. The polymorphism in our type system enables the use of general-purpose classes whose instances may serve different purposes in the computation; programmers may also hide the details of internal data structures by placing the same token on all of the objects in these data structures.


title: Modeling Crosscutting in Aspect-Oriented Mechanisms

authors:
Hidehiko Masuhara
Gregor Kiczales


title: LeakBot: An Automated and Lightweight Tool for Diagnosing Memory Leaks in Large Java Applications

authors:
Nick Mitchell
Gary Sevitsky


title: A Nominal Theory of Objects with Dependent Types

authors:
Martin Odersky
Vincent Cremet
Christine Röckl
Matthias Zenger


title: Java Subtype Tests in Real-Time

authors:
Krzysztof Palacz
Jan Vitek


title: Spontaneous Container Services

authors:
Andrei Popovici
Gustavo Alonso
Thomas R. Gross


title: Traits: Composable Units of Behaviour

authors:
Nathanael Schärli
Stéphane Ducasse
Oscar Nierstrasz
Andrew P. Black


title: MX: Mobile Object Exchange for Collaborative Applications

authors:
Liuba Shrira
Hong Tian


title: Two-Dimensional Bi-directional Object Layout

authors:
Yoav Zibin
Joseph Gil


title: Ownership Domains: Separating Aliasing Policy from Mechanism

authors:
Jonathan Aldrich
Craig Chambers


title: A Middleware Framework for the Persistence and Querying of Java Objects

authors:
Mourad Alia
Sébastien Chassande-Barrioz
Pascal Dechamboux
Catherine Hamon
Alexandre Lefebvre


title: Finding and Removing Performance Bottlenecks in Large Systems

authors:
Glenn Ammons
Jong-Deok Choi
Manish Gupta
Nikhil Swamy


title: Efficiently Verifiable Escape Analysis

authors:
Matthew Q. Beers
Christian H. Stork
Michael Franz


title: LOOJ: Weaving LOOM into Java

authors:
Kim B. Bruce
J. Nathan Foster


title: Sequential Object Monitors

authors:
Denis Caromel
Luis Mateu
Éric Tanter


title: AspectJ2EE = AOP + J2EE

authors:
Tal Cohen
Joseph Gil


title: Typestates for Objects

authors:
Robert DeLine
Manuel Fähndrich


title: Rewritable Reference Attributed Grammars

authors:
Torbjörn Ekman
Görel Hedin


title: Functional Objects


title: Semantic Casts: Contracts and Structural Subtyping in a Nominal World

authors:
Robert Bruce Findler
Matthew Flatt
Matthias Felleisen


title: Rich Interfaces for Software Modules


title: Pointer Analysis in the Presence of Dynamic Class Loading

authors:
Martin Hirzel
Amer Diwan
Michael Hind


title: Inheritance-Inspired Interface Versioning for CORBA

authors:
Skef Iterum
Ralph Campbell


title: Programming with Crosscutting Effective Views

authors:
Doug Janzen
Kris De Volder


title: Object Invariants in Dynamic Contexts

authors:
K. Rustan M. Leino
Peter Müller


title: Modules with Interfaces for Dynamic Linking and Communication

authors:
Yu David Liu
Scott F. Smith


title: Early Identification of Incompatibilities in Multi-component Upgrades

authors:
Stephen McCamant
Michael D. Ernst


title: Lock Reservation for Java Reconsidered

authors:
Tamiya Onodera
Kiyokuni Kawachiya
Akira Koseki


title: Composable Encapsulation Policies

authors:
Nathanael Schärli
Stéphane Ducasse
Oscar Nierstrasz
Roel Wuyts


title: Use Case Level Pointcuts

authors:
Jonathan Sillito
Christopher Dutchyn
Andrew David Eisenberg
Kris De Volder


title: Demand-Driven Type Inference with Subgoal Pruning: Trading Precision for Scalability

authors:
Steven Alexander Spoon
Olin Shivers


title: Customization of Java Library Classes Using Type Constraints and Profile Information

authors:
Bjorn De Sutter
Frank Tip
Julian Dolby


title: The Expression Problem Revisited


title: Adaptive Tuning of Reserved Space in an Appel Collector

authors:
José Manuel Velasco
Katzalin Olcoz
Francisco Tirado


title: Increasing Concurrency in Databases Using Program Analysis

authors:
Roman Vitenberg
Kristian Kvilekval
Ambuj K. Singh


title: Transactional Monitors for Concurrent Objects

authors:
Adam Welc
Suresh Jagannathan
Antony L. Hosking


title: Open Modules: Modular Reasoning About Advice


title: Towards Type Inference for JavaScript

authors:
Christopher Anderson
Paola Giannini
Sophia Drossopoulou


title: State Based Ownership, Reentrance, and Encapsulation

authors:
Anindya Banerjee
David A. Naumann


title: The Essence of Data Access in Comega

authors:
Gavin M. Bierman
Erik Meijer
Wolfram Schulte


title: First-Class Relationships in an Object-Oriented Language

authors:
Gavin M. Bierman
Alisdair Stuart Wren


title: Aspect-Oriented Programming Beyond Dependency Injection

authors:
Shigeru Chiba
Rei Ishikawa


title: Lightweight Defect Localization for Java

authors:
Valentin Dallmeier
Christian Lindig
Andreas Zeller


title: Sharing the Runtime Representation of Classes Across Class Loaders

authors:
Laurent Daynès
Grzegorz Czajkowski


title: Efficient Multimethods in a Single Dispatch Language

authors:
Brian Foote
Ralph E. Johnson
James Noble


title: Efficiently Refactoring Java Applications to Use Generic Libraries

authors:
Robert M. Fuhrer
Frank Tip
Adam Kiezun
Julian Dolby
Markus Keller


title: Sustainable System Infrastructure and Big Bang Evolution: Can Aspects Keep Pace?

authors:
Celina Gibbs
Chunjian Robin Liu
Yvonne Coady


title: Separation of Concerns with Procedures, Annotations, Advice and Pointcuts

authors:
Gregor Kiczales
Mira Mezini


title: Consistency Checking of Statechart Diagrams of a Class Hierarchy

authors:
Vitus S. W. Lam
Julian A. Padget


title: Evaluating Support for Features in Advanced Modularization Technologies

authors:
Roberto E. Lopez-Herrejon
Don S. Batory
William R. Cook


title: A Type System for Reachability and Acyclicity

authors:
Yi Lu
John Potter


title: Attached Types and Their Application to Three Open Problems of Object-Oriented Programming


title: The Emergent Structure of Development Tasks

authors:
Gail C. Murphy
Mik Kersten
Martin P. Robillard
Davor Cubranic


title: Expressive Pointcuts for Increased Modularity

authors:
Klaus Ostermann
Mira Mezini
Christoph Bockisch


title: Eclat: Automatic Generation and Classification of Test Inputs

authors:
Carlos Pacheco
Michael D. Ernst

abstract:
This paper describes a technique that selects, from a large set of test inputs, a small subset likely to reveal faults in the software under test. The technique takes a program or software component, plus a set of correct executions — say, from observations of the software running properly, or from an existing test suite that a user wishes to enhance. The technique first infers an operational model of the software's operation. Then, inputs whose operational pattern of execution differs from the model in specific ways are suggestive of faults. These inputs are further reduced by selecting only one input per operational pattern. The result is a small portion of the original inputs, deemed by the technique as most likely to reveal faults. Thus, the technique can also be seen as an error-detection technique.

The paper describes two additional techniques that complement test input selection. One is a technique for automatically producing an oracle (a set of assertions) for a test input from the operational model, thus transforming the test input into a test case. The other is a classification-guided test input generation technique that also makes use of operational models and patterns. When generating inputs, it filters out code sequences that are unlikely to contribute to legal inputs, improving the efficiency of its search for fault-revealing inputs.

We have implemented these techniques in the Eclat tool, which generates unit tests for Java classes. Eclat's input is a set of classes to test and an example program execution—say, a passing test suite. Eclat's output is a set of JUnit test cases, each containing a potentially fault-revealing input and a set of assertions at least one of which fails. In our experiments, Eclat successfully generated inputs that exposed fault-revealing behavior; we have used Eclat to reveal real errors in programs. The inputs it selects as fault-revealing are an order of magnitude as likely to reveal a fault as all generated inputs.


title: Interprocedural Analysis for Privileged Code Placement and Tainted Variable Detection

authors:
Marco Pistoia
Robert J. Flynn
Larry Koved
Vugranam C. Sreedhar


title: Extending JML for Modular Specification and Verification of Multi-threaded Programs

authors:
Edwin Rodríguez
Matthew B. Dwyer
Cormac Flanagan
John Hatcliff
Gary T. Leavens
Robby


title: Prototypes with Multiple Dispatch: An Expressive and Dynamic Object Model

authors:
Lee Salzman
Jonathan Aldrich


title: Loosely-Separated "Sister" Namespaces in Java

authors:
Yoshiki Sato
Shigeru Chiba


title: Chai: Traits for Java-Like Languages

authors:
Charles Smith
Sophia Drossopoulou


title: Derivation and Evaluation of Concurrent Collectors

authors:
Martin T. Vechev
David F. Bacon
Perry Cheng
David Grove


title: Static Deadlock Detection for Java Libraries

authors:
Amy L. Williams
William Thies
Michael D. Ernst


title: Turning the Network into a Database with Active XML


title: Modular Software Upgrades for Distributed Systems

authors:
Sameer Ajmani
Barbara Liskov
Liuba Shrira


title: Scoped Types and Aspects for Real-Time Java

authors:
Chris Andreae
Yvonne Coady
Celina Gibbs
James Noble
Jan Vitek
Tian Zhao


title: Responders: Language Support for Interactive Applications

authors:
Brian Chin
Todd D. Millstein


title: Object Technology - A Grand Narrative?


title: Peak Objects


title: Ambient-Oriented Programming in AmbientTalk

authors:
Jessie Dedecker
Tom Van Cutsem
Stijn Mostinckx
Theo D'Hondt
Wolfgang De Meuter


title: Session Types for Object-Oriented Languages

authors:
Mariangiola Dezani-Ciancaglini
Dimitris Mostrous
Nobuko Yoshida
Sophia Drossopoulou


title: Automated Detection of Refactorings in Evolving Components

authors:
Danny Dig
Can Comertoglu
Darko Marinov
Ralph E. Johnson


title: Variance and Generalized Constraints for C# Generics

authors:
Burak Emir
Andrew Kennedy
Claudio V. Russo
Dachuan Yu


title: Design Patterns - 15 Years Later


title: codeQuest:  Scalable Source Code Queries with Datalog

authors:
Elnar Hajiyev
Mathieu Verbaere
Oege de Moor


title: Automatic Prefetching by Traversal Profiling in Object Persistence Architectures

authors:
Ali Ibrahim
William R. Cook


title: The Closing of the Frontier


title: Managing the Evolution of Aspect-Oriented Software with Model-Based Pointcuts

authors:
Andy Kellens
Kim Mens
Johan Brichau
Kris Gybels


title: Parameterized Modules for Classes and Extensible Functions

authors:
Keunwoo Lee
Craig Chambers


title: The Continuing Quest for Abstraction


title: On Ownership and Accessibility

authors:
Yi Lu
John Potter


title: From ECOOP'87 to ECOOP 2006 and Beyond


title: SuperGlue: Component Programming with Object-Oriented Signals

authors:
Sean McDirmid
Wilson C. Hsieh


title: The Runtime Structure of Object Ownership


title: Modeling Runtime Behavior in Framework-Based Applications

authors:
Nick Mitchell
Gary Sevitsky
Harini Srinivasan


title: A Semantic Analysis of C++ Templates

authors:
Jeremy G. Siek
Walid Taha


title: Demeter Interfaces: Adaptive Programming Without Surprises

authors:
Therapon Skotiniotis
Jeffrey Palm
Karl J. Lieberherr


title: Transparently Reconciling Transactions with Locking for Java Synchronization

authors:
Adam Welc
Antony L. Hosking
Suresh Jagannathan


title: Efficient Object Querying for Java

authors:
Darren Willis
David J. Pearce
James Noble


title: Augmenting Automatically Generated Unit-Test Suites with Regression Oracle Checking


title: Early Concurrent/Mobile Objects


title: Assuring Object-Oriented Architecture


title: Erlang - Software for a Concurrent World


title: A Relational Model of Object Collaborations and Its Use in Reasoning About Relationships

authors:
Stephanie Balzer
Thomas R. Gross
Patrick Eugster


title: A Staged Static Program Analysis to Improve the Performance of Runtime Monitoring

authors:
Eric Bodden
Laurie J. Hendren
Ondrej Lhoták


title: Exception Handling: A Field Study in Java and .NET

authors:
Bruno Cabral
Paulo Marques


title: An Accidental Simula User


title: Non-null References by Default in Java: Alleviating the Nullity Annotation Burden

authors:
Patrice Chalin
Perry R. James


title: MAO: Ownership and Effects for More Effective Reasoning About Aspects

authors:
Curtis Clifton
Gary T. Leavens
James Noble

abstract: Aspect-oriented advice increases the number of places one must consider during reasoning, since advice may affect all method calls and field accesses. MAO, a new variant of AspectJ, demonstrates how to simplify reasoning by allowing programmers, if they choose, to declare limits on the control and heap effects of advice. Heap effects, such as assignment to object fields, are specified using concern domains--declared partitions of the heap. By declaring the concern domains affected by methods and advice, programmers can separate objects owned by the base program and by various aspects. When desired, programmers can also use such concern domain annotations to check that advice cannot interfere with the base program or with other aspects. Besides allowing programmers to declare how concerns interact in a program, concern domains also support a simple kind of semantic pointcut. These features make reasoning about control and heap effects easier.


title: Joinpoint Inference from Behavioral Specification to Implementation

authors:
Thomas Cottenier
Aswin van den Berg
Tzilla Elrad


title: Tracking Linear and Affine Resources with Java(X)

authors:
Markus Degen
Peter Thiemann
Stefan Wehr


title: Generic Universe Types

authors:
Werner Dietl
Sophia Drossopoulou
Peter Müller


title: A Higher Abstraction Level Using First-Class Inheritance Relations

authors:
Marko van Dooren
Eric Steegmans


title: Efficiently Generating Structurally Complex Inputs with Thousands of Objects

authors:
Bassem Elkarablieh
Yehia Zayour
Sarfraz Khurshid


title: Matching Objects with Patterns

authors:
Burak Emir
Martin Odersky
John Williams


title: Generational Real-Time Garbage Collection

authors:
Daniel Frampton
David F. Bacon
Perry Cheng
David Grove


title: On the Impact of Aspectual Decompositions on Design Stability: An Empirical Study

authors:
Phil Greenwood
Thiago T. Bartolomei
Eduardo Figueiredo
Marcos Dósea
Alessandro F. Garcia
Nélio Cacho
Cláudio Sant'Anna
Sérgio Soares
Paulo Borba
Uirá Kulesza
Awais Rashid


title: A Machine Model for Aspect-Oriented Programming

authors:
Michael Haupt
Hans Schippers


title: Morphing: Safely Shaping a Class in the Image of Others

authors:
Shan Shan Huang
David Zook
Yannis Smaragdakis


title: DirectFlow: A Domain-Specific Language for Information-Flow Systems

authors:
Chuan-Kai Lin
Andrew P. Black


title: Validity Invariants and Effects

authors:
Yi Lu
John Potter
Jingling Xue


title: Metaprogramming with Traits

authors:
John H. Reppy
Aaron Turon


title: Gradual Typing for Objects

authors:
Jeremy G. Siek
Walid Taha


title: Declarative Object Identity Using Relation Types

authors:
Mandana Vaziri
Frank Tip
Stephen Fink
Julian Dolby


title: Object-Relative Addressing: Compressed Pointers in 64-Bit Java Virtual Machines

authors:
Kris Venstermans
Lieven Eeckhout
Koen De Bosschere


title: Metamodel Adaptation and Model Co-adaptation


title: JavaGI : Generalized Interfaces for Java

authors:
Stefan Wehr
Ralf Lämmel
Peter Thiemann


title: Attribute Grammar-Based Language Extensions for Java

authors:
Eric Van Wyk
Lijesh Krishnan
Derek Bodin
August Schwerdfeger


title: AS-GC: An Efficient Generational Garbage Collector for Java Application Servers

authors:
Feng Xian
Witawas Srisa-an
ChengHuan Jia
Hong Jiang


title: ReCrash: Making Software Failures Reproducible by Preserving Object States

authors:
Shay Artzi
Sunghun Kim
Michael D. Ernst


title: Regional Logic for Local Reasoning about Global Invariants

authors:
Anindya Banerjee
David A. Naumann
Stan Rosenberg


title: Computing Stack Maps with Interfaces

authors:
Frédéric Besson
Thomas P. Jensen
Tiphaine Turpin


title: UpgradeJ: Incremental Typechecking for Class Upgrades

authors:
Gavin M. Bierman
Matthew J. Parkinson
James Noble


title: Extensible Universes for Object-Oriented Data Models

authors:
Achim D. Brucker
Burkhart Wolff


title: A Model for Java with Wildcards

authors:
Nicholas Cameron
Sophia Drossopoulou
Erik Ernst


title: An Extensible State Machine Pattern for Interactive Applications

authors:
Brian Chin
Todd D. Millstein


title: Assessing the Impact of Aspects on Exception Flows: An Exploratory Study

authors:
Roberta Coelho
Awais Rashid
Alessandro Garcia
Fabiano Cutigi Ferrari
Nélio Cacho
Uirá Kulesza
Arndt von Staa
Carlos José Pereira de Lucena


title: Bristlecone: A Language for Robust Software Systems

authors:
Brian Demsky
Alokika Dash


title: A Unified Framework for Verification Techniques for Object Invariants

authors:
Sophia Drossopoulou
Adrian Francalanza
Peter Müller
Alexander J. Summers

abstract:
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 sufficient 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.


title: Safe Cross-Language Inheritance


title: The Return of Transactions


title: Prototyping and Composing Aspect Languages

authors:
Wilke Havinga
Lodewijk Bergmans
Mehmet Aksit

abstract: Abstract. Domain specific aspect languages (DSALs) are becoming more pop-ular 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 domain specific aspect languages. A particular goal of the framework is to be general enough to support a wide range of aspect language concepts, such that existing language concepts can be easily used, and new language concepts can be quickly created. We briefly introduce the framework and its underlying model, as well as the work-flow used when implementing DSALs. Subsequently, we show mappings of sev-eral 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. 1


title: Flow Analysis of Code Customizations

authors:
Anders Hessellund
Peter Sestoft


title: Session-Based Distributed Programming in Java

authors:
Raymond Hu
Nobuko Yoshida
Kohei Honda


title: Liquid Metal: Object-Oriented Programming Across the Hardware/Software Boundary

authors:
Shan Shan Huang
Amir Hormati
David F. Bacon
Rodric M. Rabbah


title: Practical Object-Oriented Back-in-Time Debugging

authors:
Adrian Lienhard
Tudor Gîrba
Oscar Nierstrasz


title: Integrating Nominal and Structural Subtyping

authors:
Donna Malayeri
Jonathan Aldrich


title: Programming with Live Distributed Objects

authors:
Krzysztof Ostrowski
Ken Birman
Danny Dolev
Jong Hoon Ahnn


title: Inference of Reference Immutability

authors:
Jaime Quinonez
Matthew S. Tschantz
Michael D. Ernst


title: Ptolemy: A Language with Quantified, Typed Events

authors:
Hridesh Rajan
Gary T. Leavens


title: On Validity of Program Transformations in the Java Memory Model

authors:
Jaroslav Sevcík
David Aspinall


title: MTM2: Scalable Memory Management for Multi-tasking Managed Runtime Environments

authors:
Sunil Soman
Chandra Krintz
Laurent Daynès


title: Kilim: Isolation-Typed Actors for Java

authors:
Sriram Srinivasan
Alan Mycroft


title: How Do Java Programs Use Inheritance? An Empirical Study of Inheritance in Java Software

authors:
Ewan D. Tempero
James Noble
Hayden Melton


title: Online Phase-Adaptive Data Layout Selection

authors:
Chengliang Zhang
Martin Hirzel


title: Externalizing Java Server Concurrency with CAL

authors:
Charles Zhang
Hans-Arno Jacobsen


title: A Uniform Transactional Execution Environment for Java

authors:
Lukasz Ziarek
Adam Welc
Ali-Reza Adl-Tabatabai
Vijay Menon
Tatiana Shpeisman
Suresh Jagannathan


title: Coinductive Type Systems for Object-Oriented Languages

authors:
Davide Ancona
Giovanni Lagorio


title: Practical API Protocol Checking with Access Permissions

authors:
Kevin Bierhoff
Nels E. Beckman
Jonathan Aldrich


title: Java on 1000 Cores: Tales of Hardware/Software Co-design


title: Adding State and Visibility Control to Traits Using Lexical Nesting

authors:
Tom Van Cutsem
Alexandre Bergel
Stéphane Ducasse
Wolfgang De Meuter


title: Security Monitor Inlining for Multithreaded Java

authors:
Mads Dam
Bart Jacobs
Andreas Lundblad
Frank Piessens


title: EventJava: An Extension of Java for Event Correlation

authors:
Patrick Th. Eugster
K. R. Jayaram


title: Fine-Grained Access Control with Object-Sensitive Roles

authors:
Jeffrey Fischer
Daniel Marino
Rupak Majumdar
Todd D. Millstein


title: Are We Ready for a Safer Construction Environment?

authors:
Joseph Gil
Tali Shragai


title: Type-Based Object Immutability with Flexible Initialization

authors:
Christian Haack
Erik Poll


title: COPE - Automating Coupled Evolution of Metamodels and Models

authors:
Markus Herrmannsdoerfer
Sebastian Benz
Elmar Jürgens


title: Supporting Framework Use via Automatically Extracted Concept-Implementation Templates

authors:
Abbas Heydarnoori
Krzysztof Czarnecki
Thiago T. Bartolomei


title: Debugging Method Names

authors:
Einar W. Høst
Bjarte M. Østvold


title: Remote Batch Invocation for Compositional Object Services

authors:
Ali Ibrahim
Yang Jiao
Eli Tilevich
William R. Cook


title: Failboxes: Provably Safe Exception Handling

authors:
Bart Jacobs
Frank Piessens


title: Checking Framework Interactions with Relationships

authors:
Ciera Jaspan
Jonathan Aldrich


title: Classes, Jim, But Not as We Know Them - Type Classes in Haskell: What, Why, and Whither


title: Featherweight Jigsaw: A Minimal Core Calculus for Modular Composition of Classes

authors:
Giovanni Lagorio
Marco Servetto
Elena Zucca


title: Making Sense of Large Heaps

authors:
Nick Mitchell
Edith Schonberg
Gary Sevitsky


title: The Myths of Object-Orientation


title: Modular Visitor Components


title: Program Metamorphosis

authors:
Christoph Reichenbach
Devin Coughlin
Amer Diwan


title: Stepping Stones over the Refactoring Rubicon

authors:
Max Schäfer
Mathieu Verbaere
Torbjörn Ekman
Oege de Moor


title: Implicit Dynamic Frames: Combining Dynamic Frames and Separation Logic

authors:
Jan Smans
Bart Jacobs
Frank Piessens


title: From Public to Private to Absent: Refactoring Java Programs under Constrained Accessibility

authors:
Friedrich Steimann
Andreas Thies


title: Introduction to: The Myths of Object-Orientation


title: NePaLTM: Design and Implementation of Nested Parallelism for Transactional Memory Systems

authors:
Haris Volos
Adam Welc
Ali-Reza Adl-Tabatabai
Tatiana Shpeisman
Xinmin Tian
Ravi Narayanaswamy


title: Loci: Simple Thread-Locality for Java

authors:
Tobias Wrigstad
Filip Pizlo
Fadi Meawad
Lei Zhao
Jan Vitek


title: Scaling CFL-Reachability-Based Points-To Analysis Using Context-Sensitive Must-Not-Alias Analysis

authors:
Guoqing Xu
Atanas Rountev
Manu Sridharan


title: MAPO: Mining and Recommending API Usage Patterns

authors:
Hao Zhong
Tao Xie
Lu Zhang
Jian Pei
Hong Mei


title: Adding Dynamic Types to C#

authors:
Gavin M. Bierman
Erik Meijer
Mads Torgersen


title: Modules as Objects in Newspeak

authors:
Gilad Bracha
Peter von der Ahé
Vassili Bykov
Yaron Kashai
William Maddox
Eliot Miranda


title: Inline Caching Meets Quickening


title: Debugging Model-Transformation Failures Using Dynamic Tainting

authors:
Pankaj Dhoolia
Senthil Mani
Vibha Singhal Sinha
Saurabh Sinha


title: Concurrent Abstract Predicates

authors:
Thomas Dinsdale-Young
Mike Dodds
Philippa Gardner
Matthew J. Parkinson
Viktor Vafeiadis

abstract: Abstraction is key to understanding and reasoning about large computer systems. Abstraction is simple to achieve if the relevant data structures are disjoint, but rather difficult when they are partially shared, as is often the case for concurrent modules. We present a program logic for reasoning abstractly about data structures that provides a fiction of disjointness and permits compositional reasoning. The internal details of a module are completely hidden from the client by concurrent abstract predicates. We reason about a module's implementation using separation logic with permissions, and provide abstract specifications for use by client programs using concurrent abstract predicates. We illustrate our abstract reasoning by building two implementations of a lock module on top of hardware instructions, and two implementations of a concurrent set module on top of the lock module.


title: Secret Valley


title: Essential AOP: The A Calculus

authors:
Bruno De Fraine
Erik Ernst
Mario Südholt


title: The Use of Overloading in Java Programs

authors:
Joseph Gil
Keren Lenz


title: The Essence of JavaScript

authors:
Arjun Guha
Claudiu Saftoiu
Shriram Krishnamurthi

abstract: We reduce JavaScript to a core calculus structured as a small-step operational semantics. We present several peculiarities of the language and show that our calculus models them. We explicate the desugaring process that turns JavaScript programs into ones in the core. We demonstrate faithfulness to JavaScript using real-world test suites. Finally, we illustrate utility by defining a security property, implementing it as a type system on the core, and extending it to the full language.


title: Capabilities for Uniqueness and Borrowing

authors:
Philipp Haller
Martin Odersky

abstract:
An important application of unique object references is safe and efficient message passing in concurrent object-oriented programming. However, to prevent the ill effects of aliasing, practical systems often severely restrict the shape of messages passed by reference. Moreover, the problematic interplay between destructive reads-often used to implement unique references-and temporary aliasing through "borrowed" references is exacerbated in a concurrent setting, increasing the potential for unpredictable run-time errors.

This paper introduces a new approach to uniqueness. The idea is to use capabilities for enforcing both at-most-once consumption of unique references, and a flexible notion of uniqueness. The main novelty of our approach is a model of uniqueness and borrowing based on simple, unstructured capabilities. The advantages are: first, it provides simple foundations for uniqueness and borrowing. Second, it can be formalized using a relatively simple type system, for which we provide a complete soundness proof. Third, it avoids common problems involving borrowing and destructive reads, since unique references subsume borrowed references.

We have implemented our type system as an extension to Scala. Practical experience suggests that our system allows type checking real-world actor-based concurrent programs with only a small number of additional type annotations.


title: Doubts about the Positive Impact of Static Type Systems on Programming Tasks in Single Developer Projects - An Empirical Study


title: Programming Coordinated Behavior in Java

authors:
David Harel
Assaf Marron
Gera Weiss


title: Recency Types for Analyzing Scripting Languages

authors:
Phillip Heidegger
Peter Thiemann


title: Automatically Extracting Class Diagrams from Spreadsheets

authors:
Felienne Hermans
Martin Pinzger
Arie van Deursen


title: Type-Safe Eventful Sessions in Java

authors:
Raymond Hu
Dimitrios Kouzapas
Olivier Pernet
Nobuko Yoshida
Kohei Honda


title: Code Roots


title: Detecting Missing Method Calls in Object-Oriented Software

authors:
Martin Monperrus
Marcel Bruch
Mira Mezini


title: Self-Replicating Objects for Multicore Platforms

authors:
Krzysztof Ostrowski
Chuck Sakoda
Ken Birman


title: Reasoning about the Implementation of Concurrency Abstractions on x86-TSO


title: Embedding Languages without Breaking Tools

authors:
Lukas Renggli
Tudor Gîrba
Oscar Nierstrasz


title: Falling Back on Executable Specifications

authors:
Hesam Samimi
Ei Darli Aung
Todd D. Millstein


title: Correct Refactoring of Concurrent Java Code

authors:
Max Schäfer
Julian Dolby
Manu Sridharan
Emina Torlak
Frank Tip


title: JCoBox: Generalizing Active Objects to Concurrent Components

authors:
Jan Schäfer
Arnd Poetzsch-Heffter


title: Verifying Executable Object-Oriented Specifications with Separation Logic

authors:
Stephan van Staden
Cristiano Calcagno
Bertrand Meyer


title: Verifying Generics and Delegates

authors:
Kasper Svendsen
Lars Birkedal
Matthew J. Parkinson


title: A Type System for Data-Centric Synchronization

authors:
Mandana Vaziri
Frank Tip
Julian Dolby
Christian Hammer
Jan Vitek


title: Contract-Based Data Structure Repair Using Alloy

authors:
Razieh Nokhbeh Zaeem
Sarfraz Khurshid


title: Maintaining Database Integrity with Refinement Types

authors:
Ioannis G. Baltopoulos
Johannes Borgström
Andrew D. Gordon


title: Verifying Multi-object Invariants with Relationships

authors:
Stephanie Balzer
Thomas R. Gross


title: An Empirical Study of Object Protocols in the Wild

authors:
Nels E. Beckman
Duri Kim
Jonathan Aldrich

abstract: An active area of research in computer science is the prevention of violations of object protocols, i.e., restrictions on temporal orderings of method calls on an object. However, little is understood about object protocols in practice. This paper describes an empirical study of object protocols in some popular open-source Java programs. In our study, we have attempted to determine how often object protocols are defined, and how often they are used, while also developing a taxonomy of similar protocols. In the open-source projects in our study, comprising almost two million lines of code, approximately 7.2% of all types defined protocols, while 13% of classes were clients of types defining protocols. (For comparison, 2.5% of the types in the Java library define type parameters using Java Generics.) This suggests that protocol checking tools are widely applicable.


title: Counting Messages as a Proxy for Average Execution Time in Pharo


title: Reuse, Recycle to De-bloat Software

authors:
Suparna Bhattacharya
Mangala Gowri Nanda
Kanchi Gopinath
Manish Gupta


title: Types, Regions, and Effects for Safe Programming with Object-Oriented Parallel Frameworks

authors:
Robert L. Bocchino Jr.
Vikram S. Adve


title: Improving the Tokenisation of Identifier Names

authors:
Simon Butler
Michel Wermelinger
Yijun Yu
Helen Sharp


title: Detecting and Escaping Infinite Loops with Jolt

authors:
Michael Carbin
Sasa Misailovic
Michael Kling
Martin C. Rinard


title: Expressiveness, Simplicity, and Users


title: Patterns of Memory Inefficiency

authors:
Adriana E. Chis
Nick Mitchell
Edith Schonberg
Gary Sevitsky
Patrick O'Sullivan
Trevor Parsons
John Murphy


title: Tunable Static Inference for Generic Universe Types

authors:
Werner Dietl
Michael D. Ernst
Peter Müller


title: Using Structure-Based Recommendations to Facilitate Discoverability in APIs

authors:
Ekwa Duala-Ekoko
Martin P. Robillard


title: Atomic Boxes: Coordinated Exception Handling with Transactional Memory

authors:
Derin Harmanci
Vincent Gramoli
Pascal Felber


title: A Featherweight Approach to FOOL


title: CDDiff: Semantic Differencing for Class Diagrams

authors:
Shahar Maoz
Jan Oliver Ringert
Bernhard Rumpe

abstract:
Class diagrams (CDs), which specify classes and the relationships between them, are widely used for modeling the structure of object-oriented systems. As models, programs, and systems evolve over time, during the development lifecycle and beyond it, effective change management is a major challenge in software development, which has attracted much research efforts in recent years.

In this paper we present cddiff , a semantic diff operator for CDs. Unlike most existing approaches to model comparison, which compare the concrete or the abstract syntax of two given diagrams and output a list of syntactical changes or edit operations, cddiff considers the semantics of the diagrams at hand and outputs a set of diff witnesses, each of which is an object model that is possible in the first CD and is not possible in the second. We motivate the use of cddiff , formally define it, and show how it is computed. The computation is based on a reduction to Alloy. The work is implemented in a prototype Eclipse plug-in. Examples show the unique contribution of our approach to the state-of-the-art in version comparison and evolution analysis.


title: Modal Object Diagrams

abstract: While object diagrams (ODs) are widely used as a means to document object-oriented systems, they are expressively weak, as they are limited to describe specific possible snapshots of the system at hand. In this paper we introduce modal object diagrams (MODs), which extend the classical OD language with positive/negative and example/invariant modalities. The extended language allows the designer to specify not only positive example models but also negative examples, ones that the system should not allow, positive invariants, ones that all system's snapshots should include, and negative invariants, ones that no system snapshot is allowed to include. Moreover, as a primary application of the extended language we provide a formal verification technique that decides whether a given class diagram satisfies (i.e., models) a multi-modal object diagrams specification. In case of a negative answer, the technique outputs relevant counterexample object models, as applicable. The verification is based on a reduction to Alloy. The ideas are implemented in a prototype Eclipse plug-in. Examples show the usefulness of the extended language in specifying structural requirements of object-oriented systems in an intuitive yet expressive way.


title: A Co-relational Model of Data for Large Shared Data Banks


title: Mining Evolution of Object Usage

authors:
Yana Momchilova Mileva
Andrzej Wasylkowski
Andreas Zeller


title: Revisiting Information Hiding: Reflections on Classical and Nonclassical Modularity

authors:
Klaus Ostermann
Paolo G. Giarrusso
Christian Kästner
Tillmann Rendel


title: Summarized Trace Indexing and Querying for Scalable Back-in-Time Debugging

authors:
Guillaume Pothier
Éric Tanter


title: Interprocedural Exception Analysis for C++

authors:
Prakash Prabhu
Naoto Maeda
Gogul Balakrishnan
Franjo Ivancic
Aarti Gupta


title: The Eval That Men Do - A Large-Scale Study of the Use of Eval in JavaScript Applications

authors:
Gregor Richards
Christian Hammer
Brian Burg
Jan Vitek


title: A Refactoring Constraint Language and Its Application to Eiffel

authors:
Friedrich Steimann
Christian Kollee
Jens von Pilgrim


title: Can We Avoid High Coupling?

authors:
Craig Taube-Schock
Robert J. Walker
Ian H. Witten


title: Worlds: Controlling the Scope of Side Effects

authors:
Alessandro Warth
Yoshiki Ohshima
Ted Kaehler
Alan C. Kay


title: Related Types

authors:
Johnni Winther
Michael I. Schwartzbach


title: Gradual Typestate

authors:
Roger Wolff
Ronald Garcia
Éric Tanter
Jonathan Aldrich


title: The Beauty and the Beast: Separating Design from Algorithm

authors:
Dmitrijs Zaparanuks
Matthias Hauswirth


title: Frequency Estimation of Virtual Call Targets for Object-Oriented Programs

authors:
Cheng Zhang
Hao Xu
Sai Zhang
Jianjun Zhao
Yuting Chen