anchor.diff:  TraversalVertexProgram
   ~~~~~~~~~~~~~~~~~~~~~~
   
  -image:traversal-vertex-program.png[width=250,float=left] The `TraversalVertexProgram` is a "special" VertexProgram in that it can be executed via `GraphTraversal.submit()`. In Gremlin, it is possible to have the same traversal executed using either the standard OTLP-engine or the GraphComputer OLAP-engine. The difference being where the traversal is submitted.
  +image:traversal-vertex-program.png[width=250,float=left] The `TraversalVertexProgram` is a "special" VertexProgram in that it can be executed via `GraphTraversal.submit()` and the submit `:>` command in <<gremlin-console,Gremlin Console>>. In Gremlin, it is possible to have the same traversal executed using either the standard OTLP-engine or the `GraphComputer` OLAP-engine. The difference being where the traversal is submitted.
   
   NOTE: This model of graph traversal in a BSP system was first implemented by the link:http://faunus.thinkaurelius.com[Faunus] graph analytics engine and originally described in link:http://markorodriguez.com/2011/04/19/local-and-distributed-traversal-engines/[Local and Distributed Traversal Engines].
   
  
positive.code:  . `value('age')`: Have all the traversers reference the integer age of their current vertex.
   . `groupCount()`: Count how many times a particular age has been seen.
  
  While 5 iterations were presented, in fact, `TraversalVertexProgram` will execute the traversal in only 3 iterations. The reason being is that `has('age').value('age').groupCount()` can all be executed in a single iteration as any message sent would simply be to the current executing vertex. Thus, a simple optimization exists called "reflexive message passing" which simulates non-message-passing BSP iterations within a single BSP iteration.
  
  When the computation is complete a MapReduce job executes which aggregates all the `groupCount()` sideEffect `Map` objects on each vertex into a single local representation (thus, turning the distributed `Map` representation into a local `Map` representation).
  
  The same OLAP traversal can be executed using the standard `g.compute()` model, though at the expense of verbosity. `TraversalVertexProgram` provides a fluent `Builder` for constructing a `TraversalVertexProgram`. The specified `traversal()` can be either a `Supplier<Traversal>` object, a `Supplier<Traversal>` class, or a link:http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform[JSR-223] script that will generate (i.e. supply) a `Traversal`. If `traversal()` is supplied a single string, it is assumed that "gremlin-groovy" is the `ScriptEngine` to use. If two strings are supplied, then the first string denotes the `ScriptEngine` to evaluate the second string script with in order to generate (i.e. supply) the `Traversal`.
  
  
negative.code: ==>27=1
  ==>29=3
  
  In the OLAP example above, a `TraversalVertexProgram` is (logically) sent to each vertex in the graph. Each instance evaluation requires (logically) 5 BSP iterations and each iteration is interpreted as such:
  
   . `g.V()`: Put a traverser on each vertex in the graph.
   . `both()`: Propagate each traverser to the vertices `both`-adjacent to its current vertex.
  