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.

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.
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.

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.

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.

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.

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.

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.

@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"
}

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.

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.