anchor.diff:  traversal from taking longer than one hundred milliseconds to execute (the previous example takes considerably longer
   than that). While the answer provided with the `timeLimit()` is not the absolute ranking, it does provide a relative
   ranking that closely matches the absolute one. The use of `timeLimit()` in certain algorithms (e.g. recommendations)
  -can shorten the time required to get a reasonable and usable result.+can shorten the time required to get a reasonable and usable result.
  
positive.code: 
  [gremlin-groovy,modern]
  ----
  g.withSack(1f).V().repeat(both().simplePath()).emit().path().                    <1>
    group().by(project("a","b").by(limit(local, 1)).                               <2>
                                by(tail(local, 1))).
            by(order().by(count(local))).                                          <3>
    select(values).unfold().                                                       <4>
    project("v","length").
      by(limit(local, 1)).                                                         <5>
      by(count(local).sack(div).sack()).                                           <6>
    group().by(select("v")).by(select("length").sum())                             <7>
  ----
  
  <1> Defines a Gremlin link:http://tinkerpop.apache.org/docs/x.y.z/reference/#sack-step[sack] with a value of one,
  and traverses on both incoming and outgoing edges avoiding <<cycle-detection, cyclic paths>>.
  <2> Group each path by the first and last vertex.
  <3> Reduce the list of paths to the shortest path between the first and last vertex by ordering on their lengths.
  <4> Recall that at this point, there is a `Map` keyed by first and last vertex and with a value of just the shortest
  path. Extract the shortest path with `select(values)`, since that's the only portion required for the remainder of
  the traversal.
  <5> The first `by()` modulator for `project()` extracts the first vertex in the path.
  <6> The second `by()` modulator for `project()` extracts the path length and divides that distance by the value of
  the `sack()` which was initialized to 1 at the start of the traversal.
  <7> Group the resulting `Map` objects on "v" and sum their lengths to get the centrality score for each.
  
  [[eigenvector-centrality]]
  Eigenvector Centrality
  
negative.code: 
  [gremlin-groovy ]
  ----
  g.addV(id,'A').as('a').
    addV(id,'B').as('b').
    addV(id,'C').as('c').
    addV(id,'D').as('d').
    addV(id,'E').as('e').
    addV(id,'F').as('f').
    addE('next').from('a').to('b').
    addE('next').from('b').to('c').
    addE('next').from('b').to('d').
    addE('next').from('c').to('e').
    addE('next').from('d').to('e').
    addE('next').from('e').to('f').iterate()
  g.V().as("v").                                                                  <1>
    repeat(both().simplePath().as("v")).emit().                                   <2>
    filter(project("x","y","z").by(select(first, "v")).                           <3>
                                by(select(last, "v")).
                                by(select(all, "v").count(local)).as("triple").
           coalesce(select("x","y").as("a").                                      <4>
                      select("triples").unfold().as("t").
                      select("x","y").where(eq("a")).
                      select("t"),
                    store("triples")).                                            <5>
           select("z").as("length").
           select("triple").select("z").where(eq("length"))).                     <6>
    select(all, "v").unfold().                                                    <7>
    groupCount().next()                                                           <8>
  ----
  
  <1> Starting from each vertex in the graph...
  <2> ...traverse on both - incoming and outgoing - edges, avoiding <<cycle-detection, cyclic paths>>.
  <3> Create a triple consisting of the first vertex, the last vertex and the length of the path between them.
  <4> Determine whether a path between those two vertices was already found.
  <5> If this is the first path between the two vertices, store the triple in an internal collection named "triples".
  <6> Keep only those paths between a pair of vertices that have the same length as the first path that was found between them.
  <7> Select all shortest paths and unfold them.
  <8> Count the number of occurrences of each vertex, which is ultimately its betweeness score.
  
  WARNING: Since the betweeness centrality algorithm requires the shortest path between any pair of vertices in the graph,
  its practical applications are very limited. It's recommended to use this algorithm only on small subgraphs (graphs like
  the link:http://tinkerpop.apache.org/docs/current/reference/#grateful-dead[Grateful Dead graph] with only 808 vertices
  and 8049 edges already require a massive amount of compute resources to determine the shortest paths between all vertex
  pairs).
  
  [[closeness-centrality]]
  Closeness Centrality
  