anchor.diff:   ** `VertexProgram`: code executed at all vertices in a logically parallel manner with intercommunication via message passing.
    ** `MapReduce`: a computation that analyzes all vertices in the graph in parallel and yields a single reduced result.
   
  -IMPORTANT: TinkerPop is licensed under the popular link:http://www.apache.org/licenses/LICENSE-2.0.html[Apache2]
  -free software license. However, note that the underlying graph engine used with TinkerPop may have a different
  -license. Thus, be sure to respect the license caveats of the graph system product.
  -
  -image:tinkerpop-enabled.png[width=135,float=left] When a graph system implements the TinkerPop structure and process
  -link:http://en.wikipedia.org/wiki/Application_programming_interface[APIs], their technology is considered
  -_TinkerPop-enabled_ and becomes nearly indistinguishable from any other TinkerPop-enabled graph system save for
  -their respective time and space complexity. The purpose of this documentation is to describe the structure/process
  -dichotomy at length and in doing so, explain how to leverage TinkerPop for the sole purpose of graph system-agnostic
  -graph computing. Before deep-diving into the various structure/process APIs, a short introductory review of both APIs
  -is provided.
  -
   NOTE: The TinkerPop API rides a fine line between providing concise "query language" method names and respecting
   Java method naming standards. The general convention used throughout TinkerPop is that if a method is "user exposed,"
   then a concise name is provided (e.g. `out()`, `path()`, `repeat()`). If the method is primarily for graph systems
   providers, then the standard Java naming convention is followed (e.g. `getNextStep()`, `getSteps()`,
   `getElementComputeKeys()`).
   
  -== The Graph Structure
  +=== The Graph Structure
   
   image:gremlin-standing.png[width=125,float=left] A graph's structure is the topology formed by the explicit references
   between its vertices, edges, and properties. A vertex has incident edges. A vertex is adjacent to another vertex if
  
positive.code: more about it in the link:http://tinkerpop.apache.org/docs/x.y.z/dev/provider/[Graph Provider] documentation.
  
  [[the-graph-process]]
  == The Graph Process
  
  image:gremlin-running.png[width=125,float=left] The primary way in which graphs are processed are via graph
  traversals. The TinkerPop process API is focused on allowing users to create graph traversals in a
  
negative.code:  . `sideEffect`: allow the traverser to proceed unchanged, but yield some computational sideEffect in the process (S &rarrlp; S).
   . `branch`: split the traverser and send each to an arbitrary location in the traversal (S &rarr; { S~1~ &rarr; E*, ..., S~n~ &rarr; E* } &rarr; E*).
  
  Nearly every step in `GraphTraversal` either extends `MapStep`, `FlatMapStep`, `FilterStep`, `SideEffectStep`, or
  `BranchStep`.
  
  TIP: `GraphTraversal` is a link:http://en.wikipedia.org/wiki/Monoid[monoid] in that it is an algebraic structure
  that has a single binary operation that is associative. The binary operation is function composition (i.e. method
  