anchor.diff:  
   See: link:https://issues.apache.org/jira/browse/TINKERPOP-2041[TINKERPOP-2041]
   
  -==== Removed groovy-sql Dependency
  -
  -Gremlin Console and Gremlin Server no longer include groovy-sql.  If you depend on groovy-sql,
  -you can install it in Gremlin Console or Gremlin Server using the plugin system.
  -
  -Console:
  -```
  -:install org.codehaus.groovy groovy-sql 2.5.2
  -```
  -
  -Server:
  -```
  -bin/gremlin-server.sh install org.codehaus.groovy groovy-sql 2.5.2
  -```
  -
  -If your project depended on groovy-sql transitively, simply include it in your project's build file (e.g. maven: pom.xml).
  -
  -See: link:https://issues.apache.org/jira/browse/TINKERPOP-2037[TINKERPOP-2037]
  -
   ==== Changed Infix Behavior
   
   The infix notation of `and()` and `or()` now supports an arbitrary number of traversals and `ConnectiveStrategy`
  
positive.code: 
  See: link:https://issues.apache.org/jira/browse/TINKERPOP-1984[TINKERPOP-1984]
  
  ==== Reducing Barrier Steps
  
  The behavior of `min()`, `max()`, `mean()` and `sum()` has been modified to return no result if there's no input.
  Previously these steps yielded the internal seed value:
  
  [source,groovy]
  ----
  gremlin> g.V().values('foo').min()
  ==>NaN
  gremlin> g.V().values('foo').max()
  ==>NaN
  gremlin> g.V().values('foo').mean()
  ==>NaN
  gremlin> g.V().values('foo').sum()
  ==>0
  ----
  
  These traversals will no longer emit a result. Note, that this also affects more complex scenarios, e.g. if these
  steps are used in `by()` modulators:
  
  [source,groovy]
  ----
  gremlin> g.V().group().
  ......1>   by(label).
  ......2>   by(outE().values("weight").sum())
  ==>[software:0,person:3.5]
  ----
  
  Since software vertices have no outgoing edges and thus no weight values to sum, `software` will no longer show up in
  the result. In order to get the same result as before, one would have to add a `coalesce()`-step:
  
  [source,groovy]
  ----
  gremlin> g.V().group().
  ......1>   by(label).
  ......2>   by(outE().values("weight").sum())
  ==>[person:3.5]
  gremlin> g.V().group().
  ......1>   by(label).
  ......2>   by(coalesce(outE().values("weight"), constant(0)).sum())
  ==>[software:0,person:3.5]
  ----
  
  See: link:https://issues.apache.org/jira/browse/TINKERPOP-1777[TINKERPOP-1777]
  
  ==== Order of select() Scopes
  
  The order of select scopes has been changed to: maps, side-effects, paths. Previously the order was: side-effects,
  maps, paths - which made it almost impossible to select a specific map entry if a side-effect with the same name
  existed.
  
  The following snippets illustrate the changed behavior:
  
  [source,groovy]
  ----
  gremlin> g.V(1).
  ......1>   group("a").
  ......2>     by(__.constant("a")).
  ......3>     by(__.values("name")).
  ......4>   select("a")
  ==>[a:marko]
  gremlin> g.V(1).
  ......1>   group("a").
  ......2>     by(__.constant("a")).
  ......3>     by(__.values("name")).
  ......4>   select("a").select("a")
  ==>[a:marko]
  ----
  
  Above is the old behavior; the second `select("a")` has no effect, it selects the side-effect `a` again, although one
  would expect to get the map entry `a`. What follows is the new behavior:
  
  [source,groovy]
  ----
  gremlin> g.V(1).
  ......1>   group("a").
  ......2>     by(__.constant("a")).
  ......3>     by(__.values("name")).
  ......4>   select("a")
  ==>[a:marko]
  gremlin> g.V(1).
  ......1>   group("a").
  ......2>     by(__.constant("a")).
  ......3>     by(__.values("name")).
  ......4>   select("a").select("a")
  ==>marko
  ----
  
  See: link:https://issues.apache.org/jira/browse/TINKERPOP-1522[TINKERPOP-1522]
  
  ==== GraphSON BulkSet
  
  In earlier versions of TinkerPop, `BulkSet` was coerced to a `List` for GraphSON which was convenient in that it
  didn't add a new data type to support, but inconvenient in that it meant that certain process tests were not consistent
  in terms of how they ran and the benefits of the `BulkSet` were "lost" in that the "bulk" was being resolved server
  side. With the addition of `BulkSet` as a GraphSON type the "bulk" is now resolved on the client side by the language
  variant. How that resolution occurs depends upon the language variant. For Java, there is a `BulkSet` object which
  maintains that structure sent from the server. For the other variants, the `BulkSet` is deserialized to a `List` form
  which results in a much larger memory footprint than what is contained the `BulkSet`.
  
  See: link:https://issues.apache.org/jira/browse/TINKERPOP-2111[TINKERPOP-2111]
  
  === Upgrading for Providers
  
  
negative.code: 
  See: link:https://issues.apache.org/jira/browse/TINKERPOP-2075[TINKERPOP-2075]
  
  ==== Text Predicates
  
  Gremlin now supports simple text predicates on top of the existing `P` predicates. Both, the new `TextP` text
  predicates and the old `P` predicates, can be chained using `and()` and `or()`.
  