Hi Boaz:

in our paper we provide a modeling capability 
to solve the following general LAYER IMPLEMENTATION problem
adaptively.

This formulation has the advantage that it puts our work
into a more general context. Instead of traversing 
static object graphs we traverse now also dynamic 
object graphs whose parts are computed at run-time.
It makes it clear that our approach is useful for implementing
layered systems.

Geoff and Doug have already designed and implemented this idea in
Demeter/Java.

Do you think we should use this description in our paper?
-- Karl

Problem: LAYER IMPLEMENTATION 
INPUT:
Provided interface PROV and required interface REQ.
All interface  methods are assumed to be argument free and to have
a class as return type. For both REQ and PROV a class attachment
is provided.
A class attachment is of the form (Java syntax):
class C implements I1, I2, ... { 
 // hidden or empty implementation ... 
}

OUTPUT:
Implementation of PROV in terms of REQ and class attachments,
but implementation of PROV only refers "minimally" to REQ.

Our solution:
Represent REQ and class attachment as a class graph and use
strategy graphs to provide suitable abstractions of class graph.

Example: (using Java syntax)

interface I {
  A1 f1() { ... } 
  A2 f2() { ... }}
interface I1 {
  A3 f3() { ... }} 
class C implements I, I1 {}

We get edges from class 
C to class A1 labeled f1
C to class A2 labeled f2
C to class A3 labeled f3

To implement PROV, we often need to cascade methods defined
by REQ. This cascading is defined by strategy graphs.

======================
Note on generality of model (no method arguments):

If we have a method with one argument, say f with argument B

class C {
  A f(B b) {
   local_b = b;
   this.f();

  A f() {
    // uses local_b 
}

we can store the argument in an instance variable from where
it can be accessed during traversal.
Methods which need to be traversed are brought to
this form. Edges traversed before f must set local_b.

If the argument b is needed after traversing some edges,
it will be put into a visitor.
Another possibility is to put the argument