| |
ECOOP /
Technical Program Abstracts
| Modeling Crosscutting in Aspect-Oriented Mechanisms |
Hidehiko Masuhara - University of Tokyo
Gregor Kiczales - University of British Columbia
|
| Modeling four aspect-oriented programming mechanisms shows the way in which
each supports modular crosscutting. Comparing the models produces a clear
three part characterization of what is required to support crosscutting
structure: a common frame of reference that two (or more) programs can use to
connect with each other and each provide their semantic contribution. |
| Spontaneous Container Services |
Andrei Popovici - ETH Zürich
Gustavo Alonso - ETH Zürich
Thomas Gross - ETH Zürich
|
| Container technology (e.g., Enterprise Java Beans) was designed for
fixed network applications. This is unfortunate, because the ability
of containers to adapt components transparently (e.g., with
persistence and transactions) would be of great advantage in mobile
computing. In this paper, we generalize the container model into a
new software architecture, the spontaneous container. A
spontaneous container allows to homogeneously extend all
applications of a network, even if they spontaneously join or leave
the network. In the paper we show how to build a spontaneous
container by unifying different technologies into one coherent
architecture: (i) dynamic aspect-oriented programming, (ii)
containers, and (iii) infrastructures for mobile computing. Dynamic
aspect-orientation makes a spontaneous container much more flexible
than existing commercial containers. Inheriting the container
programming model allows a single focus point for modifications for
all applications in a network. Basing the overall architecture on
dynamic service brokerage and discovery allows a seamless
integration with existing infrastructures for both mobile and fixed
computing. Following these ideas, we have built and evaluated a
spontaneous container prototype that effectively and efficiently
transforms applications within a network into a distributed system
capable of transactional interaction, access control, and orthogonal
persistence. |
| A calculus of Untyped Aspect-Oriented Programs |
Radha Jagadeesan - DePaul University
Alan Jeffrey - DePaul University
James Riely - DePaul University
|
| Aspects have emerged as a powerful tool in the design and
development of systems, allowing for the encapsulation of program
transformations.
The dynamic semantics of aspects is typically specified by appealing to
an underlying object-oriented language via a compiler transformation
known as weaving.
This treatment is unsatisfactory for several reasons.
Firstly, this semantics violates basic modularity principles of
object-oriented programming.
Secondly, the converse translation from object-oriented programs
into an aspect language has a simple canonical flavor.
Taken together, these observations suggest that aspects are worthy
of study as primitive computational abstractions in their own right.
In this paper, we describe an aspect calculus and its
operational semantics.
The calculus is rich enough to encompass many of the features of
extant aspect-oriented frameworks that do not involve reflection.
The independent description of the dynamic semantics of aspects
enables us to specify the correctness of a weaving algorithm.
We formalize weaving as a translation from the aspect calculus to a
class-based object calculus, and prove its soundness. |
| Language Support for Connector Abstractions |
Jonathan Aldrich - University of Washington
Vibha Sazawal - University of Washington
Craig Chambers - University of Washington
David Notkin - University of Washington
|
Software connectors are increasingly recognized as an important consideration
in the design and implementation of object-oriented software systems.
Connectors can be used to communicate across a distributed system, coordinate
the activities of several objects, or adapt one object's interface to the
interface of another. Mainstream object-oriented languages, however, do not
provide explicit support for connectors. As a result, connection code is
intermingled with application code, making it difficult to understand, evolve,
and reuse connection mechanisms.
In this paper, we add language support for user-defined connectors to the
ArchJava language. Our design enables a wide range of connector abstractions,
including caches, events, streams, and remote method calls. Developers can
describe both the run-time semantics of connectors and the typechecking
semantics. The connector abstraction supported by ArchJava cleanly separates
reusable connection code from application logic, making the semantics of
connections more explicit and allowing engineers to easily change the
connection mechanisms used in a program. We evaluate the expressiveness and
the engineering benefits of our design in a case study applying ArchJava to
the PlantCare ubiquitous computing application.
|
| Walkabout revisited: The Runabout |
| Christian Grothoff - Purdue University
|
We present a variation of the visitor pattern which allows programmers to
write visitor-like code in a concise way. The Runabout is a library extension
that adds a limited form of multi-dispatch to Java. While the Runabout is not
as expressive as a general multiple dispatching facility, the Runabout can be
significantly faster than existing implementations of multiple dispatch for
Java, such as MultiJava. Unlike MultiJava, the Runabout does not require
changes to the syntax and the compiler.
In this paper we illustrate how to use the Runabout, detail its implementation
and provide benchmarks comparing its performance with other approaches.
|
| MX: Mobile Object Exchange for Collaborative Applications |
Liuba Shrira - Brandeis University
Hong Tian - Brandeis University
|
| MX is a new mobile caching system for collaborative applications accessing
data residing in large storage repositories. MX supports mobile exchange - a
direct user-to-user object transfer. Mobile exchange (MX) makes mobile
computing more effective because it enables certain kinds of collaborative
work that would be impossible otherwise. MX allows disconnected peers to learn
of recent unknown updates, and to apply these updates to locally-cached data.
MX validates the exchange, merging the more recent and modified data. MX
combines efficient support for coarse-grained data transfer with efficient
fine-grained validation, in a way that avoid the problem of false sharing.
Performance evaluation of the MX prototype indicates that for transactional
applications, the extra cost required to support mobile exchange is moderate.
Moreover, the extra cost is offset by the cost of accessing remote
repositories over high-latency networks.
|
| Regular Object Types |
Vladimir Gapeyev - University of Pennsylvania
Benjamin Pierce - University of Pennsylvania
|
| Regular types have been proposed as a foundation for
statically typed processing of XML and other forms of tree-structured
data. To date, however, regular types have only been explored
in special-purpose languages (e.g., XDUCE, CDUCE, and XQUERY)
with type systems designed around regular types ``from the
ground up.'' The goal of the XTATIC language is to bring regular types
to a broad audience by offering them as a lightweight extension of a
popular object-oriented language, Csharp.
We develop here the formal core of the XTATIC design—a combination
of the tree-structured data model of XDUCE and the classes-and-objects
data model of a conventional object-oriented language. Our tool for this
investigation is a tiny language called FX with features drawn from
Featherweight Java (FJ) and from the core of XDUCE. Points of
interest include (1) a smooth interleaving of the two data models, in
which XDUCE's tree structures are grafted into of FJ's class hierarchy
while objects and object types play the role of XDUCE's label values
and label types; (2) an intuitive ``semantic'' definition of the subtype
relation, inherited from XDUCE and extended to objects; and (3) a
natural encoding of XML documents and their schemas using a simple form
of singleton classes.
|
| External Uniqueness is Unique Enough |
Dave Clarke - Utrecht University
Tobias Wrigstad - Stockholm University
|
| External uniqueness is a surprising new way to
add unique references to an OOPL. The idea is that an
externally unique reference is the only reference into
an aggregate from outside the aggregate. Internal
references which do not escape the boundary of the
aggregate are innocuous and therefore permitted. Based
on ownership types, our proposal not only overcomes an
abstraction problem from which existing uniqueness
proposals suffer, it also enables many examples which
are inherently not unique, such as a unique reference
to a set of links in a doubly-linked list, without
losing the benefits of uniqueness.
|
| A Nominal Theory of Objects with Dependent Types |
Martin Odersky - EPFL
Vincent Cremet - EPFL
Christine Röckl - EPFL
Matthias Zenger - EPFL
|
| We design and study nuObj, a calculus and dependent type system for
objects and classes which can have types as members. Type members can
be aliases, abstract types, or new types. The type system can model
the essential concepts of Java's inner classes as well as
virtual types and family polymorphism found in BETA or
gbeta. It can also model most concepts of SML-style
module systems, including sharing constraints and higher-order
functors, but excluding applicative functors. The type system can thus
be used as a basis for unifying concepts that so far existed in
parallel in advanced object systems and in module systems. The paper
presents results on confluence of the calculus, soundness of the type
system, and undecidability of type checking.
|
| Traits: Composable Units of Behaviour |
Nathanael Schärli - University of Berne, Switzerland
Stephane Ducasse - University of Berne
Oscar Nierstrasz - University of Berne
Andrew Black - Oregon Health & Science University
|
| Despite the undisputed prominence of inheritance as the fundamental
reuse mechanism in object-oriented programming languages, the main variants
– single inheritance, multiple inheritance, and mixin inheritance – all
suffer from conceptual and practical problems. In the first part of this
paper, we identify and illustrate these problems. We then present traits, a
simple compositional model for structuring object-oriented programs. A trait
is essentially a group of pure methods that serves as a building block for
classes and is a primitive unit of code reuse. In this model, classes are
composed from a set of traits by specifying glue code that connects the traits
together and accesses the necessary state. We demonstrate how traits overcome
the problems arising from the different variants of inheritance, we discuss
how traits can be implemented effectively, and we summarize our experience
applying traits to refactor an existing class hierarchy.
|
| A Type System and Analysis for the
Automatic Extraction and Enforcement of Design Information |
Patrick Lam - Massachusetts Institute of Technology
Martin Rinard - Massachusetts Institute of Technology
|
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.
Our combined type system and analysis provide the model extraction
algorithms with sound heap aliasing information. Our algorithms can
therefore extract both structural models that characterize object
referencing relationships and behavioral models that capture indirect
interactions mediated by objects in the heap. Previous approaches, in
contrast, limited by an absence of aliasing information, have focused on
control-flow interactions that take place at procedure call
boundaries. We have implemented our type checker, analysis, and model
extraction algorithms and used them to automatically
extract design models. Our experience indicates that it is straightforward to
produce the token annotations and that the extracted models provide useful
insight into the structure and behavior of the program.
|
| Higher-Order Hierarchies |
| Erik Ernst - University of Aarhus
|
This paper introduces the notion of higher-order inheritance
hierarchies. They are useful because they provide well-known
benefits of object-orientation at the level of entire
hierarchies– benefits which are not available with current
approaches.
Three facets must be adressed: First, it must be possible to create
hierarchies incrementally based on existing hierarchies, such that
commonalities are expressed via reuse, not duplication.
Second, the hierarchies must themselves be
organized into hierarchies, such that their relationships are
made explicit and can be exploited in a type safe manner. Finally, it must be
possible to write generic code that works on every
hierarchy derived from the hierarchy for which it was written.
This paper presents a language design that supports such a notion
of higher-order hierarchies. It has been implemented in context
of a full-fledged, statically typed language.
|
| Two-Dimensional Bi-Directional Object Layout |
Yoav Zibin - Technion
Yossi Gil - Technion
|
| C++ object layout schemes rely on (sometimes numerous) compiler generated
fields.
We describe a new language-independent object layout scheme, which is space
optimal,
i.e., objects are contiguous, and contain no compiler generated fields other
than
a single type identifier. As in C++ and other multiple inheritance languages
such
as Cecil and Dylan, the new scheme sometimes requires an extra level of
indirection
to access some of the fields. Using a data set of 28 hierarchies, totaling
almost
50,000 types, we show that the new scheme improves field access efficiency
over
standard implementations, and competes favorably with (the non-space optimal)
highly
optimized C++ specific implementations. The benchmark includes a new
analytical
model for computing the frequency of indirections in a sequence of field
access
operations. Our layout scheme relies on whole-program analysis, which requires
about 10 micro-seconds per type on a contemporary architecture
(Pentium III,~900Mhz, 256MB machine), even in very large hierarchies.
|
| LeakBot: An Automated and Lightweight
Tool for Diagnosing Memory Leaks in Large Java Applications |
Nick Mitchell - IBM T.J. Watson Research Center
Gary Sevitsky - IBM T.J. Watson Research Center
|
Despite Java's automatic reclamation of memory, memory leaks remain an
important problem. For example, we frequently encounter memory leaks that
cause production servers to crash. These servers represent an increasingly
common class of Java applications: they are large scale and they make heavy
use of frameworks. For these applications, existing tools require too much
expertise, and, even for experts, require many hours interpreting low-level
details. In addition, they are often too expensive to use in practice. We
present an automated, adaptive, and scalable tool for diagnosing memory leaks,
called LeakBot.
LeakBot incorporates three new techniques. First, it automatically ranks data
structures by their likelihood of containing leaks. This process dramatically
prunes the set of candidate structures, using object reference graph
properties and knowledge of how leaks occur. Second, it uses Co-Evolving
Regions to identify suspicious regions within a data structure and
characterize their expected evolution. Third, it uses the first two methods to
derive a lightweight way to track those regions' actual evolution as the
program runs. These techniques are mutually beneficial: we need only monitor
what is highly ranked, and, because the tracking is so cheap, a region's rank
can be continually updated with information from production machines. Finally,
this whole process can be done without user assistance.
We demonstrate LeakBot's effectiveness on a number of large-scale
applications that we have analyzed as part of the ongoing consulting
practice our group maintains. We have found that the ranking analysis scales
(e.g. written in Java, it analyzes 10^6 objects in 30 seconds with a 300M
heap), is selective (e.g. it prunes that set to three candidate leak roots),
and is accurate (it discounts non-leakingroots). The CER generation completes
in tens of seconds. The lightweight tracking refines the rankings, while
lowering throughput by less than 5%.
|
| Java Subtype tests in Real Time |
Krzysztof Palacz - Purdue University
Jan Vitek - Purdue University
|
| Dynamic subtype tests are frequent operations in Java programs.
Naive implementations can be costly in space and running time.
The techniques that have been proposed to reduce these costs are either
restricted in their ability to cope with dynamic class loading or may
suffer from pathological performance degradation penalizing certain
programming
styles. We present R&B, a subtype test algorithm designed
for time and space constrained environments such as Real-Time Java
which require predictable running times, low space overheads and dynamic
class loading. Our algorithm is constant-time, requires an average
of 10.8 bytes per class of memory and has been shown to yield an average
2.5% speedup on a production virtual machine. The Real-Time Specification
for Java requires dynamic scoped memory access checks on every
reference assignment. We extend R&B to perform memory access checks
in constant-time.
|
| Discovering Algebraic Specifications from Java Classes |
Johannes Henkel - University of Colorado
Amer Diwan - University of Colorado
|
| We present and evaluate an automatic tool for extracting algebraic
specifications from Java classes. Our tool maps a Java class to an algebraic
signature and then uses the signature to generate a large number of terms.
The tool evaluates these terms and based on the results of the evaluation, it
proposes equations. Finally, the tool generalizes equations to axioms and
eliminates many redundant axioms. Since our tool uses dynamic information, it
is not guaranteed to be sound or complete. However, we manually inspected the
axioms generated in our experiments and found them all to be correct.
|
| A Refinement Algebra for Object-Oriented Programming |
| Paulo Borba - Federal University of Pernambuco
Augusto Sampaio - Federal University of Pernambuco
Marcio Cornalio - Federal University of Pernambuco
|
| In this article we introduce a comprehensive set of algebraic
laws for ROOL, a language similar to sequential Java but with
a copy semantics.
We present a few laws of commands, but focus
on the object-oriented features of the language.
We show that this set of laws is complete in the sense that
it is sufficient to reduce an arbitrary ROOL program to a
normal form expressed in a restricted subset of the ROOL
operators. We also propose a law for data refinement that
generalises the technique from traditional modules to class
hierarchies. Together, these laws are expressive
enough to derive more elaborate rules that can be useful, for
example, to formalize object-oriented design practices; this
is illustrated through the systematic derivation of some
refactorings from the proposed laws.
|
| Object-Oriented Reading Techniques for
Inspection of UML Models – An Industrial Experiment |
Reidar Conradi - Norwegian University of Science and Technology
Parastoo Mohagheghi - Ericsson
Tayyaba Arif - Norwegian University of Science and Technology
Lars Christian Hegde - Norwegian University of Science and Technology
Geir Arne Bunde - Agder University College
Anders Pedersen - Agder University College
|
| Object-oriented design and modeling with UML has become a central part of
software development in industry. Software inspections are used to
cost-efficiently increase the quality of the developed software by early
defect detection and correction. Several models presenting the total system
need to be inspected for consistency with each other and with external
documents such as requirement specifications. Special Object Oriented Reading
Techniques (OORTs) have been developed to help inspectors in the individual
reading step of inspection of UML models. The paper describes an experiment
performed at Ericsson in Norway to evaluate the cost-efficiency of tailored
OORTs in a large-scale software project. The results showed that the OORTs fit
well into an incremental development process, and managed to detect defects
not found by the existing reading techniques. The study demonstrated the need
for further development and empirical assessment of these techniques, and for
better integration with industrial work practice.
|
| |
 |
|
|
|
|
ECOOP is sponsored by
in cooperation with ACM SIGPLAN
|
top
