Adaptive Programming (AP)
works by splitting an object-oriented
program into at least two aspects: the behavior and
the object containment structure (class graph).  A new 
modeling mechanism, called a succinct traversal
specification allows the behavior
part of the program to automatically adapt to a large number of changes
in the class graph.  This effectively loosens the object model enough
that makes many maintenance and evolution tasks for OO programs become
simpler when using AP.

<P>
AP directly supports evolutionary design: it becomes easier
to change objects and to make the software work again.
It becomes easier to reuse programs since adaptive programs
commit to less object structure than traditional programs.

<P>
We have recently improved the concept of adaptive programming
by introducing explicit interface class graphs against which
collaborations are written.
An adaptive program is composed of class graphs 
(e.g., UML class diagrams or structural architectures),
collaborations expressed as adaptive plug and play components (APPCs,
see the Mezini/Lieberherr OOPSLA '98 paper),
aspect descriptions and
name maps which map APPCs and aspect descriptions into the class graph.
An APPC consists of an interface class graph (both a structural
and a behavioral part) plus an implementation written in a structure
generic way against the structural part of the interface class graph.
By letting each component of an
application define a view (interface class graph) 
to the implementation class graph, and
by programming to that interface, we achieve a big win in reusability:
to reuse the component, one needs only match the interface to
the implementation class graph and the component should work in that setting
too.