AP/S++: Case-study of a MOP for purposes of software evolution
Cristina Videira Lopes and Karl Lieberherr
We study a recent programming paradigm known as Adaptive Programming
(AP) as an ideal candidate for a metaobject protocol (MOP) for
object-oriented programming languages; we call it the APMOP. The
major benefit of the APMOP is to provide a mechanism for writing
base-level programs in a structure-shy manner. Doing so, the programs
are more robust to changes in the structural aspects of the
applications. We describe AP/S++, an implementation of the APMOP
using the Scheme-based, object-oriented language S++. AP/S++ is a
compile-time MOP and has no negative effects on the run-time
performance of programs.
The contributions of this paper are: (i) to show a new application for
reflection; (ii) to clearly identify the abstraction boundaries of AP;
and (iii) to propose an implementation of the APMOP that can easily
be reproduced in many object-oriented programming languages.
Full paper.
Adaptive Parameter Passing
Cristina Videira Lopes
Control over parameter passing is a key issue in distributed
object-oriented applications. The two simplest solutions - passing
objects by global reference and passing objects by deep copy - both
have significant drawbacks. Instead, an intermediate amount of copying
is often best. However, achieving the right amount of copying is
difficult for two reasons: (i) compilers and operating systems cannot
automatically make the best decision on how much to copy; (ii) there
hasn't been a good mechanism for the programmer to express the
intermediate amount of copying that should be done.
Full paper.
Graph-based optimizations for parameter passing in remote invocations
Cristina Videira Lopes
This paper proposes a graph-based solution to the problem of parameter
passing in distributed object-oriented applications. The solution
presented here makes use of graph directives for the purpose of
optimizing the copying of objects which are passed as parameters in
remote invocations. These specifications are done using a very simple
graph traversal language -- GOOP. The resulting parameter passing
scheme can be drastically improved for every situation in the
applications.
Full paper.
Separation of Concerns
Walter Hürsch and Cristina Videira Lopes
This paper identifies and analyzes the emergence of a new paradigm in
software engineering, called "separation of concerns, which tries
to formally separate the basic algorithm from special purpose concerns
such as synchronization, real-time constraints, and location
control. This separation allows for the locality of different kinds of
information in the programs, making them easier to write, understand,
and modify. We identify the major concerns existing in today's
software applications, and analyze recent proposals in the literature
that address single concerns. Furthermore, we study the commonalities
of these proposals and discuss how they can be used to achieve
separation of concerns in general. Finally, we address the problem of
composition of several separated concerns.
Full paper.
Abstracting Process-to-Function Relations in Concurrent
Object-Oriented Applications
Cristina Videira Lopes and Karl Lieberherr
This paper presents a programming model for concurrent object-oriented
applications by which concurrency issues are abstracted and separated
from the code. The main goal of the model is to minimize dependency
between application specific functionality and concurrency control.
Doing so, software reuse can be effective and concurrent programs are
more flexible, meaning that changes in the implementation of the
operations don't necessarily imply changes in the synchronization
scheme (and vice-versa). We make an analysis of concurrent
computation, review existing systems and their inherent limitations,
and discuss the fundamental problems in abstracting concurrency. Then
we propose a solution based on lessons learned with adaptive software,
introducing the concept of synchronization patterns. The result is a
programming model by which data, operations and concurrency control
are minimally interdependent.
Full paper.
Generative Patterns
Cristina Videira Lopes and Karl Lieberherr
We use the concept of generative patterns to refer to patterns
from which object-oriented programs can be automatically obtained. Two
kinds of generative patterns are presented: propagation patterns
and synchronization patterns, the former being the basis for
automatic program generation, and the later being an extension for the
purpose of concurrent programming.
Full paper.
Integrating Adaptive Programming into Existing Object-Oriented Analysis
and Design Methods: Do It Yourself Adaptiveness
Martin Spit and Sjaak Brinkkemper and Karl Lieberherr
The principles of adaptive object-oriented programming hold many promises for
speeding up of systems development and reuse of software.
Unfortunately, it is hard to study these principles without
their current context of the Demeter Method. In this paper the theory
and instrumentation of method engineering is applied to define a clear, concise and ready-to-use method fragment to support adaptive functionality
specifications. The fragment is not embedded in the
context of a specific method and can be used to
integrate adaptiveness into nearly all object-oriented
analysis and design methods. As an example the
fragment is integrated into the Object Modeling Technique (OMT) from
Rumbaugh et al.
Preventive Program Maintenance in Demeter/Java
Karl Lieberherr and Doug Orleans
Demeter/Java is an implementation of Adaptive Programming (AP) for Java. Demeter/Java programs consist
of Java code together with programs in a small language to express traversals, visitor methods, and class
diagrams. Demeter/Java programs are typically written in a preventive maintenance style using traversal
strategies for expressing traversals. The resulting programs are very robust under changes to the class diagrams
and visitors. This preventive maintenance style also leads to simpler programs, making both software
development and maintenance easier.
Full paper.
Traversals of Object Structures: Specification and Efficient
Implementation
Karl Lieberherr and Boaz Patt-Shamir
We present a new approach, called strategies, to the
task of traversing object structures.
In our approach traversals are defined using a high-level
directed graph description, which is compiled into a dynamic road map to
assist run-time traversals.
The complexity of the compilation algorithm is polynomial in the
size of the strategy graph and the class graph of the given
application.
The implementation is practical and
allows for dynamically creating and modifying the existing
traversal strategy.
A prototype of the system has been developed and is being successfully
used.
Previous approaches to traversal specifications were less general
(corresponding to either a series-parallel or a tree graph),
and their compilation algorithms were of exponential complexity
in some cases.
In an additional result we show that this bad behavior is inherent to
the static traversal code generated by previous implementations,
where traversals are carried out by invoking methods without parameters.
This paper presents a new mechanism that allows programmers to express
in a natural and succinct way how much of the object graph should be
copied to the remote context. The specifications are done using a very
simple declarative meta-language -- GOOP -- that has graphs of classes
as its domain. GOOP allows the specification of: (i) whether the
parameter object should be passed by copy or by reference; and (ii) if
passed by copy, what parts of the parameter object's graph should be
copied.
@INPROCEEDINGS{spit:masters-thesis,
AUTHOR = "Martin Spit and Sjaak Brinkkemper and Karl Lieberherr",
TITLE = "Integrating Adaptive Programming into Existing Object-Oriented
Analysis and Design Methods: Do It Yourself Adaptiveness",
BOOKTITLE = oois,
YEAR = "1996",
ADDRESS = "London",
PAGES = "",
EDITOR = "",
PUBLISHER = "South Bank University"
}
Click here
for full paper.