anchor.diff:  ==>27=1
   ==>29=3
   gremlin> result.memory().iteration
  -==>5
  +==>2
   gremlin> result.memory().runtime
   ==>7
   
  
positive.code:  . When evaluating traversals that rely on path information (i.e. the history of the traversal), practical computational limits can easily be reached due the link:http://en.wikipedia.org/wiki/Combinatorial_explosion[combinatoric explosion] of data. With path computing enabled, every traverser is unique and thus, must be enumerated as opposed to being counted/merged. The difference being a collection of paths vs. a single 64-bit long at a single vertex. For more information on this concept, please see link:http://thinkaurelius.com/2012/11/11/faunus-provides-big-graph-data-analytics/[Faunus Provides Big Graph Data].
   . When traversals of the form `x.as('a').y.someSideEffectStep('a').z` are evaluated, the `a` sideEffect is stored in the path information of the traverser and thus, such traversals turn on path calculations when executed on a GraphComputer.
   . Steps that are concerned with the global ordering of traversers do not have a meaningful representation in OLAP. For example, what does <<order-step,`order()`>>-step mean when all traversers are being processed in parallel? Even if the traversers were aggregated and ordered, then at the next step they would return to being executed in parallel and thus, in an unpredictable order. Other steps of this nature include <<orderby-step,`orderby()`>> and <<shuffle-step,`shuffle()`>>. When these steps are executed at the end of a traversal (i.e the final step), the `TraverserMapReduce` job ensures the resultant serial representation is ordered accordingly.
   . Steps that are concerned with providing a global aggregate to the next step of computation do not have a correlate in OLAP. For example, <<fold-step,`fold()`>>-step can only fold up the objects at each executing vertex. Next, even if a global fold was possible, where would it go? Which vertex would be the host of the data structure? The `fold()`-step only makes sense as an end-step whereby a MapReduce job can generate the proper global-to-local data reduction.
negative.code:                       mapReduce(LambdaMapReduce.build().
                          map("b.emit(a.value('counter'))").
                          reduce("c.emit(a,b.sum())").
                          memory('a.next()').
                          memoryKey('sum').create()).submit().get()
  ==>result[tinkergraph[vertices:6 edges:6],memory[size:1]]
  gremlin> result.memory().sum
  