There is an interesting interplay between constrained
genericity in class graphs and positive strategies.
A positive strategy does not use "bypassing".
Both constrained genericity for class graphs and
positive strategies need to be present
for a convenient programming system.

If we only have unconstrained genericity as with Java collections
the traversal graphs get too big and unnecessary traversal
is performed at run-time. With constrained genericity as 
with C++ templates or Demeter parameterized class graphs we have
more information at traversal graph computation time
and the traversals become more efficient.

If we don't have positive strategies, i.e. all strategies are
of the form

from {A,...} bypassing{...} to {B,...}

we cannot express positive traversal intent outlining "where we want to go"
at a high level.

As long as Java lacks constrained genericity, the best solution is
to decorate the positive strategies with sufficient bypassing
clauses for edges to make the traversals efficient.
But this makes the traversal strategies harder to maintain.
However, this is only a temporary work-around until Java gets
GJ or a version of it.

-- Karl

==========================
The bus example:
/course/com3362/sp99/DJ/nested-bus-routes-cyclic-strat-wysiwyg/

Summarized Traversal Graph:
BusRoute = <fbuses> MyVector <fbusStops> MyVector.
BusStop = <fwaiting> MyVector <fnewBusRoute> BusRoute.
Bus = <fpassengers> MyVector.
Person = .          
MyVector = <elements> Object.
Object : BusRoute | BusStop | Bus | Person .

String wysiwyg = " bypassing {BusRoute,BusStop,Person} ";
    Strategy sg = new Strategy(
	 "{" +
		"BusRoute -> BusStop" + wysiwyg +
		       "BusStop -> Person" + wysiwyg +
			      "BusStop -> BusRoute" + wysiwyg +
				   "}");

Notice the strategy graph cycle: BusRoute -> BusStop BusStop -> BusRoute
that makes the recursion explicit. Here we need to use the
graph notation.
Will traverse into nested BusRoute-objects.
===
/course/com3362/sp99/DJ/nested-bus-routes-wysiwyg

Summarized Traversal Graph 
BusRoute = <fbuses> MyVector <fbusStops> MyVector.
// notice that we traverse the buses collection
// although we don't find any interesting Person-objects.
// Lack of type information in class graph leads
// to inefficiency. Bypassing leads to more efficient code
// than through. But less robust.
// Parameterization in class graph helps.
BusStop =                       <fwaiting> MyVector.
MyVector =                      <elements> Object.
Object : BusStop | Bus | Person .
Bus =                   <fpassengers> MyVector.
Person =                        .  

    Strategy sg = new Strategy(
	"from BusRoute" + wysiwyg +
	      "through BusStop" + wysiwyg +
		  "to Person");  

This will not traverse into nested bus route.