////
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements.  See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
////
TinkerPop3 CHANGELOG
====================

TinkerPop 3.1.0 (A 187 On The Undercover Gremlinz)
--------------------------------------------------

image::https://raw.githubusercontent.com/apache/incubator-tinkerpop/master/docs/static/images/gremlin-gangster.png[width=185]

[[release-3.1.0-incubating]]
TinkerPop 3.1.0 (Release Date: November 16, 2015)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

This release also includes changes from <<release-3-0-1-incubating, 3.0.1-incubating>> and <<release-3-0-2-incubating, 3.0.2-incubating>>.

* Fixed bug in Gryo and GraphSON (with embedded types) serialization for serialization of results returned from `Map.entrySet()`.
* `Transaction` settings for `onReadWrite` and `onClose` are now `ThreadLocal` in nature of standard transactions.
* Optimized `BulkLoaderVertexProgram`. It now uses `EventStrategy` to monitor what the underlying `BulkLoader` implementation does (e.g. whether it creates a new vertex or returns an existing).
* Integrated `NumberHelper` in `SumStep`, `MinStep`, `MaxStep` and `MeanStep` (local and global step variants).
* Gremlin Console remoting to Gremlin Server now supports a configuration option for assigning aliases.
* `CountMatchAlgorithm`, in OLAP, now biases traversal selection towards those traversals that start at the current traverser location to reduce message passing.
* Fixed a file stream bug in Hadoop OLTP that showed up if the streamed file was more than 2G of data.
* Added the ability to set thread local properties in `SparkGraphComputer` when using a persistent context.
* Bumped to Neo4j 2.3.0.
* Deprecated "rebindings" as an argument to Gremlin Server and replaced it with "aliases".
* Added `PersistedInputRDD` and `PersistedOutputRDD` which enables `SparkGraphComputer` to store the graph RDD in the context between jobs (no HDFS serialization required).
* Renamed the `public static String` configuration variable names of TinkerGraph (deprecated old variables).
* Added `GraphComputer.configure(key,value)` to allow engine-specific configurations.
* `GraphStep` is no longer in the `sideEffect`-package and is now in `map`-package (breaking change).
* Added support for mid-traversal `V()`-steps (`GraphStep` semantics updated).
* Fixed `Number` handling in `Operator` enums. Prior this change a lot of operations on mixed `Number` types returned a wrong result (wrong data type).
* Fixed a bug in Gremlin Server/Driver serializer where empty buffers were getting returned in certain cases.
* Renamed `ConjunctionX` to `ConnectiveX` because "conjunction" is assumed "and" (disjunction "or"), where "connective" is the parent concept.
* Removed `PathIdentityStep` as it was a hack that is now solved by `Traversal.Admin.addTraverserRequirement()`.
* Added `Traversal.Admin.addTraverserRequirement()` to allow a traversal strategy or source to add requirements (not only step determined anymore).
* Added `TraverserRequirement.ONE_BULK` to state the traverser does not handle bulk.
* Added `GraphTraversalSource.withBulk(boolean)` to enabled users to compute only using `bulk=1`.
* Gremlin Server supports Netty native transport on linux.
* Removed the need for `GFunction` (etc.) closure wrappers in Gremlin-Groovy as `as Function` can be used to convert closures accordingly.
* Added `SelectColumnStep` (`select(keys)` and `select(values)`). Deprecated `mapKeys()` and `mapValues()`.
* Renamed `gremlin.hadoop.graphInputRDD` and `gremlin.hadoop.graphOutputRDD` to `gremlin.spark.graphInputRDD` and `gremlin.spark.graphOutputRDD`, respectively.
* Fixed a bug in `FoldStep` around bulking. This could be a breaking change, but it is the correct semantics.
* Previous `group()`-behavior steps are accessible via the deprecated `groupV3d0()`-steps.
* `GroupStep` and `GroupSideEffectStep` now do lazy reductions to reduce memory footprint. Breaking change for `group()` semantics.
* Added `GroupStepHelper` with various static methods and classes that are used by both `GroupStep` and `GroupSideEffectStep`.
* Added `BarrierStep` interface with `processAllStarts()` method which process all starts up to yielding the barrier result.
* Fixed a severe threading issue in `TinkerGraphComputer`.
* The location of the jars in HDFS is now `hadoop-gremlin-x.y.z-libs` to ensure multiple TinkerPop versions don't clash.
* `GiraphGraphComputer` will only upload the jars to HDFS if it doesn't already exist (to help speed up startup time).
* `GiraphGraphComputer.workers()` is smart about using threads and machines to load balance TinkerPop workers across cluster.
* `GraphComputer.workers(int)` allows the user to programmatically set the number of workers to spawn.
* Added `GryoSerializer` as the new recommended Spark `Serializer`. Handles `Graph` and `GryoMapper` registries.
* `GryoPool` now makes use of `GryoPool.Builder` for its construction.
* Bumped to Apache Hadoop 2.7.1.
* Bumped to Apache Giraph 1.1.0.
* Bumped to Apache Spark 1.5.1.
* Split Hadoop-Gremlin apart such there is now `hadoop-gremlin`, `spark-gremlin`, and `giraph-gremlin` (and respective `GremlinPlugins`).
* Added `LambdaCollectingBarrierStep` which generalizes `NoOpBarrierStep` and allows for `barrier(normSack)`-type operations.
* Fixed bugs in the Gremlin Server's NIO protocol both on the server and driver side.
* Added `Path.popEquals(Pop,Object)` to check for path equality based on `Pop` (useful for `TraverserRequirement.LABELED_PATH`).
* Added `Operator.assign` to allow setting a direct value.
* `Operator` is now a `BinaryOperator<Object>` with appropriate typecasting for respective number operators.
* Simplified `SackValueStep` so it now supports both `sack(function)` and sack(function).by()`. Deprecated `sack(function,string)`.
* Added `Parameters` object to allow for the parameters of a step to be retrieved at runtime via a traversal.
* Redesigned (though backwards compatible) `AddEdgeStep`, `AddVertexStep`, and `AddPropertyStep` (and respective `GraphTraversal` API).
* Added `GraphTraversalSource.inject()` so users can spawn a traverser with non-graph objects.
* `GraphStep` can now take a single argument `Collection` which is either elements or element ids (i.e. `g.V([1,2,3])` is supported now).
* Added `LoopsStep` to make the loop counter accessible within `repeat()`, `until()` and `emit()`.
* Gephi Plugin no longer requires manual insert of `store` steps to visualize a traversal.
* Added a `TinkerIoRegistry` that registers a custom serializer for Gryo that will serialize an entire `TinkerGraph` instance.
* Added configuration options to Gephi Plugin for setting the size of nodes visualized.
* Replaced `DedupBijectionStrategy` with the more effective `FilterRankingStrategy`.
* `ComputerAwareSteps` must not only handle step ids, but also step labels.
* Renamed `B_O_P_SE_SL_Traverser` to `B_LP_O_P_SE_SL_Traverser` as it now supports `TraverserRequirement.LABELED_PATH`.
* Added `B_LP_O_S_SE_SL_Traverser` in support of `TraverserRequirement.LABELED_PATH`.
* Added `TraverserRequirement.LABELED_PATH` which only generates path data for steps that are labeled (greatly increases the likelihood of bulking).
* Fixed a bug in `Path` usage that required an API update: `Path.addLabel()` is now `Path.extend(Set<String>)` and `Traverser.addLabels(Set<String>)`.
* Made `Path` iterable, so that it can be `unfold()`'ed and used by local steps like `min(local)`, `max(local)`, etc.
* `WhereTraversalStep` and `WherePredicateStep` are now the only "special" `Scoping` steps after `MatchStartStep` in `match()`.

Bugs
^^^^

* TINKERPOP3-774 order / dedup issues
* TINKERPOP3-799 [Proposal] with()-modulator for stream level variable binding.
* TINKERPOP3-801 groupCount() fails for vertices (elements?) (using Spark)
* TINKERPOP3-811 AddPropertyStepTest fails "all of a sudden"
* TINKERPOP3-823 addV() broken for multi-value properties
* TINKERPOP3-843 Misspecified HADOOP_GREMLIN_LIBS generates NullPointerException
* TINKERPOP3-857 Add GraphComputer.config(key,value)
* TINKERPOP3-895 Use "as BinaryOperator" and remove GBinaryOperator
* TINKERPOP3-903 Fix empty buffer return upon buffer capacity exceeded
* TINKERPOP3-910 In session transaction opened from sessionless request
* TINKERPOP3-918 ComputerVerificationStrategy is too restrictive
* TINKERPOP3-926 Renamed TinkerGraph public statics to common pattern used for other statics.
* TINKERPOP3-948 AbstractGremlinProcessTest.checkMap not asserted in GroupTest
* TINKERPOP3-953 Artifact equality is not evaluating properly
* TINKERPOP3-955 HashMap$Node not serializable

Improvements
^^^^^^^^^^^^

* TINKERPOP3-297 Ensure Consistent Behavior Over Deleted Elements *(breaking)*
* TINKERPOP3-333 Support VertexProperty in PartitionStrategy
* TINKERPOP3-391 More fluency in GraphComputer for parameterization.
* TINKERPOP3-616 Use Spark 1.3.0 in Hadoop-Gremlin.
* TINKERPOP3-624 Passing Detached/Referenced to Graph.vertices/edge()
* TINKERPOP3-680 Configurable Channelizer for Gremlin Driver
* TINKERPOP3-728 Improve Remote Graph Object Treatment in Console
* TINKERPOP3-756 Provide a strict parsing option for GraphMLReader
* TINKERPOP3-760 Make loop counter accessible within repeat()
* TINKERPOP3-762 Allow mid-traversal V() (and E())
* TINKERPOP3-765 Decompose AbstractTransaction for different transactional contexts *(breaking)*
* TINKERPOP3-767 Path should play well with "local" steps.
* TINKERPOP3-768 MatchStep in OLAP should be smart about current vertex.
* TINKERPOP3-769 Make the introduction of the TP3 docs story better.
* TINKERPOP3-772 TraverserRequirement.LABELED_PATH
* TINKERPOP3-796 Support merge binary operator for Gremlin sacks *(breaking)*
* TINKERPOP3-798 [Proposal] Rename mapKeys()/mapValues() to select(keys) and select(values).
* TINKERPOP3-802 Provide sack(object) so that the sack can be directly set.
* TINKERPOP3-803 A better solution to g.V(someCollection.toArray())
* TINKERPOP3-805 Enforce AutoCloseable Semantics on Transaction *(breaking)*
* TINKERPOP3-821 Improve testing around TraversalHelper around recursive methods
* TINKERPOP3-825 [Proposal] SetBulkStep (sideEffectStep)
* TINKERPOP3-826 OneToManyBarrierStrategy
* TINKERPOP3-827 Add a console session to the PageRank section of the docs.
* TINKERPOP3-829 TinkerGraphComputer should support the user specified thread/worker count.
* TINKERPOP3-835 Shade Jackson Dependencies *(breaking)*
* TINKERPOP3-836 Support Hadoop2 in place of Hadoop1
* TINKERPOP3-850 Reduce Graph.addVertex overload ambiguity *(breaking)*
* TINKERPOP3-851 GroupCountStep needs a by() for the count.
* TINKERPOP3-861 Solve "The Number Problem" for Operator (and follow on operators)
* TINKERPOP3-863 [Proposal] Turn off bulking -- or is there something more general? (hope not).
* TINKERPOP3-866 GroupStep and Traversal-Based Reductions *(breaking)*
* TINKERPOP3-868 Allow Spark Gremlin Computer to Reuse Spark Contexts
* TINKERPOP3-874 Rename Gremlin-Spark properties using gremlin.spark prefix. *(breaking)*
* TINKERPOP3-876 Rename VendorOptimizationStrategy XXXOptimizationStrategy *(breaking)*
* TINKERPOP3-879 Remove deprecated promoteBindings from GremlinExecutor *(breaking)*
* TINKERPOP3-885 Change Transaction.onReadWrite() to be a ThreadLocal setting *(breaking)*
* TINKERPOP3-888 GraphTraversal.property overloads *(breaking)*
* TINKERPOP3-896 Simplify the {{withSack}} methods of {{GraphTraversalSource}}. *(breaking)*
* TINKERPOP3-897 Remove deprecated GSupplier, GFunction, GConsumer, etc. methods. *(breaking)*
* TINKERPOP3-898 Rename ConjuctionP and ConjuctionStep to ConnectiveP and ConnectiveStep *(breaking)*
* TINKERPOP3-899 Bump to the latest version of Neo4j.
* TINKERPOP3-900 Provide by(object) which compiles to by(constant(object))
* TINKERPOP3-901 Option for use of Netty epoll on Linux to reduce GC pressure
* TINKERPOP3-904 BulkLoaderVertexProgram optimizations
* TINKERPOP3-905 Harden time oriented tests in ResultQueueTest
* TINKERPOP3-907 getters for RepeatStep.untilTraversal and RepeatStep.emitTraversal
* TINKERPOP3-908 Use line breaks in documentation
* TINKERPOP3-909 Improve steps that handle numeric data
* TINKERPOP3-911 Allow setting Thread Specific Spark JobGroup/Custom Properties based on hadoop conf
* TINKERPOP3-913 Rename Gremlin Server arguments rebinding to alias
* TINKERPOP3-914 DriverRemoteAcceptor in Gremlin Console supports aliases
* TINKERPOP3-917 Add HadoopGraph.open(String)
* TINKERPOP3-922 Add a book for Developer Documentation
* TINKERPOP3-923 Add a book for Tutorials
* TINKERPOP3-925 Use persisted SparkContext to persist an RDD across Spark jobs.
* TINKERPOP3-931 Make it possible to extend the core OpProcessor implementations
* TINKERPOP3-933 Improve release process to get files named properly
* TINKERPOP3-935 Add missing "close" operation to the session opProcessor docs

TinkerPop 3.0.0 (A Gremlin Rāga in 7/16 Time)
---------------------------------------------

image::https://raw.githubusercontent.com/apache/incubator-tinkerpop/master/docs/static/images/gremlin-hindu.png[width=225]

[[release-3-0-2-incubating]]
TinkerPop 3.0.2 (Release Date: October 19, 2015)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Cleaned up `ext/` directory when plugin installation fails for `gremlin-server` and `gremlin-console`.
* Fixed issues in `gremlin-server` when configured for HTTP basic authentication.
* Made `BulkLoaderVertexProgram` work for any persistent TP3-supporting graph (input and output).
* `TreeSideEffectStep` now implements `PathProcessor` which fixed a `ComputerVerificationStrategy` issue.
* Added a shell script that verifies source and binary distributions.
* Fixed a bulk related bug in `GroupStep` when used on `GraphComputer` (OLAP).
* Gremlin Server binary distribution now packages `tinkergraph-gremlin` and `gremlin-groovy` as plugins to be consistent with Gremlin Console's packaging.
* The `RepeatStep` clauses (`until()`,`emit()`,`repeat()`) can only be set at most one time in order to prevent user confusion.
* Fixed a `clone()` bug in `RepeatStep`, `TreeStep`, `GroupCountStep`, `GroupStep`, and `TraversalRing`.
* Fixed a thread context bug in `TinkerGraphComputer`.
* Fixed issues with the `gremlin-driver` related to hanging connections in certain conditions.
* TinkerGraph now has an option for persistence where the data is saved on `close()` and, if present, loaded on `open()`.
* Added an overload for `GremlinExecutor.eval()` that takes a `Lifecycle` object to override some default settings from `GremlinExecutor.Builder`.
* Improved session closing for transactional graphs during shutdown of Gremlin Server.
* Fixed id parameter used in tests for `GroovyStoreTest` and `GroovyRepeatTest` to not be treated as an embedded string.
* `GraphStep` will convert any `Vertex` or `Edge` ids to their id `Object` prior to submission to `GraphComputer` (OLAP).

Bugs
^^^^

* [TINKERPOP3-814] - ConnectionPool can fill with dead Connections
* [TINKERPOP3-816] - Gryo deserialization of error response with null message causes NPE and protocol desync
* [TINKERPOP3-817] - Gryo serialization of large responses fails and causes protocol desync
* [TINKERPOP3-840] - TreeTest Is not being ignored via ComputerVerificationStrategy
* [TINKERPOP3-849] - gremlin-server doesn't close sessions on 'close' opcode
* [TINKERPOP3-855] - sasl authentication type error due to Json format
* [TINKERPOP3-865] - Errors with HTTP REST basic auth
* [TINKERPOP3-867] - TinkerGraphProvider does not initialize temp dir
* [TINKERPOP3-870] - Rebound client requires a connection to occur on the underlying client.
* [TINKERPOP3-877] - Driver hangs if SSL enabled on server but not on client

Improvements
^^^^^^^^^^^^

* [TINKERPOP3-828] - TinkerGraph can supportPersistence(), should we allow it.
* [TINKERPOP3-830] - process-docs.sh introduces extra white space dependent on console width
* [TINKERPOP3-839] - Docs should have a ${version.number} under the logo.
* [TINKERPOP3-852] - A shell script that validates the distribution artifacts at release time
* [TINKERPOP3-853] - TinkerPop Logo in JavaDoc index.html
* [TINKERPOP3-858] - Cleanup after failed :install

[[release-3-0-1-incubating]]
TinkerPop 3.0.1 (Release Date: September 2, 2015)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* `Compare` now uses `BigDecimal` internally to ensure that precision is not lost on standard number comparisons.
* Renamed `ComputerVerificationStrategy` to `VerificationStrategy` so all the verification strategies can use it.
* Added `StandardVerificationStrategy` that throws exceptions for illegal traversal patterns on the standard engine (which extends to `GraphComputer`).
* Added `GraphFeatures.supportsConcurrentAccess()` to allows `Graph` implementations to signify if multiple instances can access the same data.
* Clarified semantics of `Transaction.close()` in unit tests - now refers only to closing the current transaction in the current thread.
* `Neo4jGraph` no longer uses `OptOut` on `TransactionTest.shouldRollbackOnCloseWhenConfigured` (formerly `shouldRollbackOnShutdownWhenConfigured`)
* Gremlin Server initialization scripts can now return a `Map` of values that will become global bindings for the server.
* Introduced the `--dryRun` option to the document generation process which ignores actual script execution in the Gremlin Console.
* Fixed bug in `EventStrategy` around property changed events when calling `property` without cardinality or meta-property values.
* Improved support for the `Accept` header for REST-based requests in Gremlin Server.
* `GraphFactory` now allows specification of the class to use to instantiate the `Graph` through the `GraphFactoryClass` annotation.
* Added `wrapAdjacencyList` and `unwrapAdjacencyList` options to `GraphSONWriter` and `GraphSONReader` respectively, thus allowing valid JSON to be written/read if the user desires.
* Added Gremlin Server/Driver authentication support via SASL.
* Added Basic HTTP authentication support for REST in Gremlin Server.
* Added Gremlin Server plugin to help with "credential graph" management (used in conjunction with authentication features of Gremlin Server).
* Added "secure" Gremlin Server/Driver example configuration files.
* Adjusted configuration for javadoc generation to eliminate error messages.
* Removed "reserved" graph concept names from tests (e.g. "label", "edge", "value") to support the convention of avoiding these strings for property names.
* Introduced `GraphProvider.Descriptor` which annotates a `GraphProvider` implementation to describe what `GraphComputer` implementation will be used.
* Modified `OptOut` to include a `computers` attribute which allows the `Graph` to opt-out of computer-based tests for specific computation engines.
* Added a `SandboxExtension` that can be plugged into `TypeCheckedCustomizerProvider` and `CompileStaticCustomizerProvider` to control classes and methods that can be used in the `GremlinGroovyScriptEngine`.
* Added a number of new `ImportCustomizerProvider` implementations such as, `TimedInterruptCustomizerProvider`, `TypeCheckedCustomizerProvider` and others.
* Refactored `GremlinGroovyScriptEngine` to make more general use of `ImportCustomizerProvider` implementations.
* Removed `SecurityCustomizerProvider` class and the "sandbox" configuration on the `ScriptEngines` class - this was an experimental feature and not meant for public use.
* Removed dependency on `groovy-sandbox` from the `gremlin-groovy` module.

Bugs
^^^^

* [TINKERPOP3-770] - Exception while AddPropertyStep tries to detach vertex property
* [TINKERPOP3-780] - Use of fold() in repeat()
* [TINKERPOP3-782] - map(Traversal) should declare requirements of child
* [TINKERPOP3-785] - Gremlin Server Not Properly Reporting Port Conflict
* [TINKERPOP3-792] - select at start of match traversal on Map can fail
* [TINKERPOP3-794] - IncidentToAdjecentStrategy malfunction
* [TINKERPOP3-804] - Failed installing neo4j-gremlin extension on Windows 7
* [TINKERPOP3-822] - Neo4j GraphStep with element arguments ignores has  *(breaking)*

Improvements
^^^^^^^^^^^^

* [TINKERPOP3-576] - Gremlin Server Authentication
* [TINKERPOP3-582] - Remove Groovy Sandbox Dependency
* [TINKERPOP3-610] - General graph concept names in test schema
* [TINKERPOP3-656] - IoRegistry Chaining
* [TINKERPOP3-690] - Be able to OPT_OUT for Standard, but not Computer *(breaking)*
* [TINKERPOP3-699] - GraphSON writeGraph not producing valid json object
* [TINKERPOP3-750] - Compare should not have special case for Number
* [TINKERPOP3-752] - Make Gremlin Server Better Respect ACCEPT
* [TINKERPOP3-764] - Unify semantics of Transaction.close() in tests and documentation *(breaking)*
* [TINKERPOP3-771] - IoRegistry Instantiation With GryoPool
* [TINKERPOP3-778] - Support GraphFactory location via annotation.
* [TINKERPOP3-791] - Document rules for committers
* [TINKERPOP3-797] - order() seems to only like List? *(breaking)*
* [TINKERPOP3-808] - TraversalComparator.comparator needs a getter

TinkerPop 3.0.0 (Release Date: July 9, 2015)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Modified the `GremlinExecutor` to catch `Throwable` as opposed to `Exception` so as to properly handle `Error` based exceptions.
* Modified the `GremlinGroovyScriptEngine` compilation configuration to prevent inappropriate script evaluation timeouts on standalone functions.
* Added a custom configuration for "timed interrupt" in the `ScriptEngines` instantiation of the `GremlinGroovyScriptEngine`.
* Added `mapKeys()` (`MapKeyStep`) and `mapValues()` (`MapValueStep`) to get the keys and values of a map, respectively.
* `select()` no longer supports empty arguments. The user must specify the keys they are selecting.
* `MatchStep` and `match()` no longer have a "start label" parameter -- it is computed if the incoming traverser does not have requisite labels.
* Turned transactional testing back on in Gremlin Server using Neo4j.
* Renamed `Transaction.create()` to `Transaction.createThreadedTx()`.
* Added `TraversalParent.removeGlobalChild()` and `TraversalParent.removeLocalChild()`.
* Added a `clear` option to the Gephi Plugin to empty the Gephi workspace.
* Refactored `ResultSet` and related classes to stop polling for results.
* `AbstractStep` now guarantees that bulk-less and null-valued traversers are never propagated.
* Added `dedup(string...)` which allows for the deduplication of a stream based on unique scope values.
* Fixed multiple bugs in the Gephi Plugin related to refactoring of traversal side-effects.
* Split `WhereStep` into `WherePredicateStep` and `WhereTraversalStep` to simplify internals.
* Prevent the driver from attempting to reconnect on a dead host if the `Cluster.close()` method has been called.
* Renamed the "deactivate" option on `:plugin` command to "unuse" to be symmetric with the "use" option.
* Added `Traversal.toStream()` to turn the `Traversal<S,E>` into a `Stream<E>`.
* Added `Scoping.Variable` enum of `START` and `END` which allows the `Scoping` step to specify where its bindings are.
* `ComputerVerificationStrategy` is smart about not allowing `WhereXXXStep` with a start-variable to run in OLAP as it selects the value from the path.
* Rewrote `MatchStep` where it now works on `GraphComputer`, solves more patterns, provides plugable execution plans, supports nested AND/OR, `not()`-patterns, etc.
* Renamed `Graphs` in Gremlin Server to `GraphManager`.
* Fixed bug in Gremlin Driver where client-side serialization errors would not bubble up properly.
* Fixed problem in Gremlin Server to ensure that a final `SUCCESS` or `NO_CONTENT` message assured that the transaction was successful in sessionless requests.
* Arrow keys for cycling through command history now work in Gremlin Console when being used on Windows.
* Added `NotStep` and `not(traversal)` for not'ing a traversal (integrates like `ConjunctionStep`).
* Removed `TraversalP`. Traversals and `P`-predicates are completely separate concepts.
* `has(key,traversal)` is now an alias for `filter(__.values(key).traversal)` using `TraversalFilterStep`.
* Simplified `SubgraphStrategy` by using `TraversalFilterStep` instead of the more complex `WhereStep`.
* Added `TraversalMapStep`, `TraversalFlatMapStep`, `TraversalFilterStep`, and `TraversalSideEffectStep` which all leverage an internal traversal.
* Added `Path.get(pop,label)` as default helpers in `Path`.
* Added `Pop.first`, `Pop.last`, and `Pop.all` as enums for getting single items from a collection or a list of said items.
* Changed `GremlinServer.start()` to return a `CompletableFuture` that contains the constructed `ServerGremlinExecutor`.
* Restructured `IoTest` breaking it up into smaller and more logically grouped test cases.
* Gremlin Server `Settings` now has sensible defaults thus allowing the server to be started with no additional configuration.
* Fixed garbled characters in Gremlin Console that notably showed up in `:help`
* Replaced dependency on `groovy-all` with individual Groovy dependencies as needed.
* Bumped `org.gperfutils:gbench` to the `0.4.3` and a version explicitly compatible with Groovy 2.4.x.
* Renamed `KeyStep` to `PropertyKeyStep` to be consistent with `PropertyValueStep`.
* Added `Gremlin-Lib-Paths` to modify paths in plugin `lib` directory.
* Modified the capabilities of `Gremlin-Plugin-Paths` to delete paths that have no value on the right-hand-side of the equals sign.
* The REST API in Gremlin Server now requires parameters to be defined with a "bindings." prefix.
* Modified the REST API in Gremlin Server to accept rebindings.
* Added `rebindings` optional argument to sessionless requests to allow global bindings to be rebound as needed.
* Added `LazyBarrierStrategy` which "stalls" a traversal of a particular form in order to gain a bulking optimization.
* `CollectingBarrierStep` supports `maxBarrierSize` for "lazy barrier," memory conservation.
* `Scoping` now has `getScopeKeys()` to get the keys desired by the scoping step.
* Refactored SSL support in the Gremlin Server/Driver.
* Factored out `ServerGremlinExecutor` which contains the core elements of server-side script execution in Gremlin Server.
* Bumped to netty 4.0.28.Final.
* Refactored the `Mutating` interface and introduce `CallbackRegistry` interface around `EventStrategy`.
* Changed `onReadWrite` and `onClose` of `AbstractTransaction` to be synchronized.
* Added `LabelP` to support index lookups and `has()` filtering on `Neo4jGraph` multi-label vertices.
* `AddEdgeStep` is now a `Scoping` step.
* Added a fully defined set of `Graph.Feature` implementations to `EmptyGraph`.
* Dropped dependency on `org.json:json` - used existing Jackson dependency.
* Added back neo4j-gremlin as the licensing of the Neo4j API is now Apache2.
* Added `willAllowId` method to features related to vertices, edges and vertex properties to test if an identifier can be use when `supportsUserSuppliedIds` is `true`.
* Fixed a bug in `GraphTraversal.choose(predicate,trueTraversal,falseTraversal)`.
* Removed `MapTraversal`, `MapTraverserTraversal`, `FilterTraversal`, and `FilterTraverserTraversal` as these are simply `__.map(function)` and `__.filter(predicate)`.
* Include `hadoop-gremlin` Hadoop configuration sample files in Gremlin Console distribution.
* Iteration of results in Gremlin Server occur in the same thread as evaluation and prior to transaction close.
* TinkerGraphComputer now supports every `ResultGraph`/`Persist` combination.
* `GraphComputerTest` extended with validation of the semantics of all `ResultGraph`/`Persist` combinations.
* GiraphGraphComputer no longer requires an extra iteration and MapReduce job to derive the full `Memory` result.
* SparkGraphComputer now supports `InputRDD` and `OutputRDD` to allow vendors/users to use a `SparkContext` to read/write the graph adjacency list.
* Added `Scoping.getScopeValue()` method so all "selecting" steps use the same pattern for map, path, and sideEffect data retrieval.

TinkerPop 3.0.0.M9 (Release Date: May 26, 2015)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Removed `GraphComputer.isolation()` as all implementations use standard BSP.
* Added a Gremlin Server `LifeCycleHook` to ensure that certain scripts execute once at startup and once at shutdown.
* `has(key)` and `hasNot(key)` are now aliases for `where(values(key))` and `where(not(values(key)))`, respectively.
* TinkerGraph classes are now final to restrict user and vendor extension.
* Added `TraversalStrategy.VendorOptimization` to ensure that all TinkerPop optimizations execute first on the known TinkerPop steps.
* Added `TailGlobalStep` and `TailLocalStep` (`tail()`) which gets objects from the end of the traversal stream.
* `AndStep` and `OrStep` are now simply markers where `WhereStep(a.and(b).and(c)...and(z))` is the compilation.
* Moved `Compare`, `Contains`, `Order`, `Operator`, and `P` to `process/traversal` from `structure/` as they are process-based objects.
* `HasContainer` now uses `P` predicate as helper methods and tests are more thorough on `P`.
* Changed Gremlin Server integration/performance tests to be runnable from within the `gremlin-server` directory or from the project root.
* Moved the string methods of `TraversalHelper` to `StringFactory`.
* Renamed JSON-related serializers for Gremlin Server to be more consistent with GraphSON naming.
* Removed `HasTraversalStep` in favor of new `P.traversal` model with `HasStep`.
* Fixed bug in `WsGremlinTextRequestDecoder` where custom serializers from graphs were not being used.
* Added `AndP` which allows for the `and()`-ing of `P` predicates.
* `Order.opposite()` is now `reversed()` as that is a `Comparator` interface method with the same semantics.
* `Compare/Contains/P.opposite()` are now `negate()` as that is a `BiPredicate` interface method with the same semantics.
* `has(traversal)` is replaced by `where(traversal)` and `has(key,traversal)`. `HasXXX` is always with respects to an element property.
* Added `TraversalScriptHelper` with static methods for dynamically creating a `Traversal` from a JSR 223 `ScriptEngine`.
* Changed `SubgraphStrategy` to take `Traversal` rather than `Predicate` for filtering.
* Improved `SubgraphStrategy` to only modify the `Traversal` if filtering was required.
* Improved logging of errors in the `HttpGremlinEndpointHandler` to include a stracktrace if one was present.
* Moved `AbstractGremlinSuite.GraphProviderClass` to `org.apache.tinkerpop.gremlin.GraphProviderClass`.
* Simplified the Gremlin-Groovy test suite where there is now no distinction between `STANDARD` and `COMPUTER` tests.
* `VertexProgram` and `MapReduce` now add a `Graph` parameter to `loadState(Graph, Configuration)`.
* Added `ScopingStrategy` which auto-scopes `select()` and `where()` so the language looks clean.
* Added `Scoping` as a marker interface to state that a step desires a particular `Scope`.
* `SelectStep`, `SelectOneStep`, and `WhereStep` support both `Scope.local` and `Scope.global` for `Map<String,Object>` or `Path` analysis, respectively.
* Fixed a bug in the `TraversalStrategies` sort algorithm.
* Removed numerous unused static utility methods in `TraversalHelper`.
* TinkerGraph process suite tests are now running with and without strategies in place.
* Added `IncidentToAdjacentStrategy` which rewrites `outE().inV()`, `inE().outV()` and `bothE().otherV()` to `out()`, `in()` and `both()` respectively.
* Renamed `ComparatorHolderRemovalStrategy` to `OrderGlobalRemovalStrategy` as it now only applies to `OrderGlobalStep`.
* Anonymous traversal no longer have `EmptyGraph` as their graph, but instead use `Optional<Graph>.isPresent() == false`.
* Added `Traversal.Admin.setGraph(Graph)` as strategies that need reference to the graph, need it across all nested traversals.
* `AbstractLambdaTraversal` is now smart about `TraversalParent` and `TraversalStrategies`.
* Fixed bug in `GraphML` reader that was not allowing `<edge>` elements to come before `<node>` elements as allowable by the GraphML specification.
* Added `VertexFeature.getCardinality`.
* Added `AdjacentToIncidentStrategy` which rewrites `out().count()` to `outE().count()` (and similar such patterns).
* `GryoPool` now takes a `Configuration` object which allows setting the size of the pool and the `IoRegistry` instance.
* Added `PersistResultGraphAware` interface which is used by `OutputFormats` to specify persistence possibilities for a Hadoop `GraphComputer`.
* `ElementIdStrategy` now allows the identifier property to be set directly (and not only by specifying `T.id`).
* Added sample configuration files for registering a `TraversalStrategy` in Gremlin Server.
* Added response status code for `NO_CONTENT` to represent output for a successful script execution without a result (e.g. an empty `Iterator`).
* Removed the notion of a "terminator" message from the Gremlin Server protocol - new response status code for `PARTIAL_CONTENT`.
* `Path` and `Step` labels are ordered by the order in which the respective `addLabel()` calls were made.
* A `Step` now has a `Set<String>` of labels. Updated `as()` to take a var args of labels.
* Dropped `BatchGraph` from the code base - it will be replaced by bulk loader functionality over OLAP.
* `TraversalSideEffects` now implements `Optional` semantics. Less code as Java8 provides the helper methods.
* `TraversalScriptSupplier` now takes an `Object` var args for setting `ScriptEngine` bindings if needed.
* `Compare` is now more lenient on `Number`-types.
* Removed `Compare.inside` and `Compare.outside` as they are not primitive comparators and should be composed from primitives.
* Introduced `P` (predicate) for cleaner looking `is()`, `has()`, and `where()` calls -- e.g. `has('age',eq(32))`.
* `GraphTraversalSource` is now the location for `withXXX()` operations. No longer do they exist at `GraphTraversal`.
* All `Traverser` objects now extend from `AbstractTraverser` or a child that ultimately extends from `AbstractTraverser`.
* OLTP `select()` now returns a list for traversals with duplicate labels (as this was a unintended side-effect of `SparsePath`).
* Removed the `SparsePath` optimization as it led to numerous corner-case inconsistencies.
* `VertexWritable` serializes and deserializes the `StarGraph` object -- no more intermediate `DetachedXXX` objects.
* Gremlin Server better supports the settings for the high and low watermark that will slow writes to clients that are lagging.
* Added `GraphReader.readObject()` and `GraphWriter.writeObject` abstractions for those implementations that can support them.
* Altered `GraphWriter.writeVertices()` method to take an `Iterator` of vertices rather than a `Traversal`.
* GraphSON format for output from `GraphWriter.writeVertex`, `GraphWriter.writeVertices`, and `GraphWriter.writeGraph` have all changed now that they use `StarGraph` serialization.
* Gryo format for output from `GraphWriter.writeVertex`, `GraphWriter.writeVertices`, and `GraphWriter.writeGraph` have all changed now that they use `StarGraph` serialization.
* Added read and write methods to `GraphReader` and `GraphWriter` for `Property` and `VertexProperty`.
* Reduced object creation in GraphSON during serialization.
* Moved `T` tokens to the `structure/` package as its more general than `process/`.
* `Attachable.attach()` now takes a `Method` to determine whether to attach via `GET`, `CREATE`, or `GET_OR_CREATE`.
* Decreased size of Gremlin Server `RequestMessage` and `ResponseMessage` serialization payloads and reduced object creation.
* `Graph.empty()` no longer required with the introduction of `ShellGraph` which is a placeholder for a graph class and computer.
* `VertexProperty.Cardinality` default is now vendor chosen. If the vendor has not preference, they should use `Cardinality.single`.
* `Messenger.receiveMessages()` no longer takes a `MessageScope` and thus, consistent behavior between message-passing and message-pulling systems.
* Changed the `gremlin.tests` environment variable for test filtering to the more standard convention of `GREMLIN_TESTS` and made it work for all test suites.
* Removed `back()`-step as `select()`-step provides the same behavior with more intelligent optimizations and `by()`-modulation.
* Removed `Graph.Helper` method annotation and related infrastructure in tests.
* Modified header of Gryo to be 16 bytes instead of 32 (and removed the version stamp).
* Removed the concept of handling version in Gryo via the builder as it wasn't really accomplishing the capability of ensuring backward compatibility.
* Moved `Exceptions.propertyRemovalNotSupported` from `Element` to `Property` for consistency.
* Provided a method for Gremlin Server to bind `TraversalSource` objects for use in scripts.
* Modified the reference implementation for dealing with "custom" identifier serialization in GraphSON - See `IoTest.CustomId` for the example.
* Modified `g.vertices/edges` and related methods and tests to support non-type specific querying (e.g. `g.V(1)` and `g.V(1L)` should both return the same result now).
* `TinkerGraph` supports an `IdManager` which helps enforce identifier types and improve flexibility in terms of how it will respond to queries around identifiers.
* `DetachedXXX` now uses the standard `structure/` exceptions for unsupported operations.
* Added private constructors to all `Exceptions` inner classes in the respective `structure/` interfaces.
* Re-introduced `ReferenceXXX` to ensure a smaller data footprint in OLAP situation (`DetachedXXX` uses too much data).
* `Attachable` now has a set of static exception messages in an `Exceptions` inner class.
* Added `StarGraph` which is a heap efficient representation of a vertex and its incident edges (useful for `GraphComputer` implementations).
* `TraverserSet` uses a `FastNoSuchElementException` on `remove()` for increased performance.
* Add `Profiling` interface to enable vendors to receive a `Step's MutableMetrics`.

TinkerPop 3.0.0.M8 (Release Date: April 6, 2015)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Removed Neo4j-Gremlin from this distribution due to GPL licensing. Working with Neo4j team to reintroduce by M9.
* Altered structure of plugin directories for Gremlin Server and Gremlin Console to allow for the full `lib` directory with all dependencies and the lighter `plugin` directory which contains filtered dependencies given the path.
* Improved `OptOut` to allow for exclusion of a group of tests by specifying a base test class.
* `GraphComputerTest` is now Java8 specific and much easier to extend with new test cases.
* Merged the `gremlin-algorithm` module into `gremlin-test`.
* Removed `LambdaVertexProgram` and `LambdaMapReduce` as it will be one less thing to maintain.
* Gremlin Console accepts a `max-iteration` configuration via the standard `:set` command to limit result iteration.
* `Vertex.property()` default behavior is now `Cardinality.single`.
* Added `ElementIdStrategy` as a `TraversalStrategy`.
* Introduce `AbstractTransaction` to simplify implementation of standard transactional features for vendors.
* Added `EventStrategy` to generate `Graph` modification events to listeners.
* Added test to enforce return of an empty `Property` on `VertexProperty.property(k)` if no meta properties exist.
* Added methods to registered transaction completion listeners on `Transaction` and provided a default implementation.
* Fixed bug in Neo4j where return of an empty meta property was returning a `NullPointerException`.
* Refactored step API -- the TinkerPop3 steps are the foundation for any domain specific language (including graph).
* `MapReduce` now has `workerStart(Stage)` and `workerEnd(Stage)` methods with analagous semantics to `VertexProgram`.
* Hadoop-Gremlin `ObjectWritable` now leverages Kryo for data serialization.
* `GiraphGraphComputer` supports arbitrary objects as the vertex id -- previously, only long ids were supported.
* Added `VertexProgramPool` to support thread safe pooling of vertex programs for graph computers that provide threaded workers.
* Added `GryoPool` to support thread safe pooling of Gryo readers and writers.
* Added `TraversalSource` which contextualizes a traversal to a graph, DSL, execution engine, and runtime strategies.
* Added `AddVertexStep` (`addV`), `AddPropertyStep` (`property`), and changed `AddEdgeStep` to a map-step instead of a sideEffect-step.
* Added `compile` method to `GremlinExecutor` and related classes.
* Fixed bug in Gremlin Server that was generating extra response messages on script evaluation errors.
* Changed the `Memory` API to not return the mutated value on `or`, `and`, `incr` as it is too difficult to implement faithfully in a distributed system.
* Added `SparkGraphComputer` to Hadoop-Gremlin which uses Apache Spark as the underlying computing engine.
* Renamed "Gremlin Kryo" to "Gryo".
* Refactored `TinkerWorkerPool` to use `ExecutorService` so as to reuse threads when executing graph computer functions.
* Removed `Reducing.Reducer` and `ReducingStrategy`. Previous `Reducing` classes are now `MapReducer` classes.
* Refactored the "process" test suite to allow for better test configuration with respect to different `TraversalEngine` implementations.
* Added `hasNot(traversal)` which is a faster way of doing `has(traversal.count().is(0L))`.
* `TraversalStrategy.apply(traversal)` is the new method signature as the `TraversalEngine` can be retrieved from the `Traversal`.
* `TraversalEngine` is now an interface and provided to the traversal by the graph. `Graph` methods added to set the desired traversal engine to use.
* Added `count(local)`, `sum(local)`, `max(local)`, `min(local)`, `mean(local)`, `dedup(local)`, `sample(local)` and `range(local)` for operating on the local object (e.g. collection, map, etc.).
* `TraversalComparator` exists which allows for `order().by(outE().count(),decr)`.
* Added Apache Rat plugin to detect the proper inclusion of license headers in files.
* A `Traversal` now respects thread interruption during iteration, throwing a `TraversalInterruptionException` if it encounters interruption on the current thread.
* Apache refactoring: `com.tinkerpop` -> `org.apache.tinkerpop`.
* `Traversal` is now `Serializable` and with most queries no longer needing lambdas, Gremlin-Java works over the wire.
* Added `VertexProperty.Cardinality` with `list`, `set`, and `single`. No more `Vertex.singleProperty()` method.
* Added `RangeByIsCountStrategy` that adds a `RangeStep` in front of `.count().is(<predicate>, <value>)` to minimize the amount of fetched elements.
* Added `CoalesceStep` / `coalesce()` that emits the first traversal which emits at least one element.
* Added more syntactic sugar tricks to the Gremlin sugar plugin -- `&`, `|`, `select from`, `gt`, etc.
* `Traversal.Admin` is consistent internal to steps, traversals, strategies, etc. For the user, `Traversal` is all they see.
* `TraversalHolder` is now called `TraversalParent` with the child/parent terminology used throughout.
* Added `GroovyEnvironmentPerformanceSuite`.
* Provided more robust shutdown capabilities for the thread pools used in `GremlinExecutor`.
* A massive `process/` package reorganization -- class names are still the same, just in new packages.
* Bumped `neo4j-graph` to Neo4j 2.1.6.
* Bumped to Groovy 2.4.1.
* Added a new "performance" test suite for Gremlin Process.
* Steps now only operate with traversals -- no more lambdas. Lambda->`Traversal` conversion utilities added.
* `SideEffectStep` always requires a `Consumer`. Steps that were consumer-less simply extends `AbstractStep`.
* Simplified the `Neo4jGraph` implementation by now allowing `cypher()` mid-traversal. Only available via `g.cypher()`.
* Moved `clock()` out of the Utility plugin. It is now available to both Groovy and Java.
* Changed the `OptOut` annotation to allow for ignoring an entire test case using a wildcard.
* Added `AndStep` and `OrStep` filters to support arbitrary conjunction of traversals.
* `__` is now a class with static `GraphTraversal` methods and thus `repeat(out())` is possible.
* Added `IsStep` / `.is()` that supports filtering scalar values.
* `Neo4jGraph` and `TinkerGraph` no longer create new `Feature` instances on each feature check.
* Added `Compare.inside` and `Compare.outside` for testing ranges. Removed `between()` as now its `has('age',inside,[10,30])`.
* `GraphTraversal.has()` no longer requires the element type to be cast in the traversal definition.
* Fixed a `ConcurrentModificationException` bug in TinkerGraph that occurred when doing full vertex/edge scans and removing elements along the way.
* Added `Scope.local` and `Scope.global` in support of `OrderLocalStep` and `OrderGlobalStep` via `order(scope)`.
* Added `Order.keyIncr`, `Order.keyDecr`, `Order.valueIncr`, and `Order.valueDecr` in support of `Map` sorting.
* Added `Order.shuffle` and removed `shuffle()` in favor of `order().by(shuffle)`.
* Changed `Order implements Comparator<Comparable>` to `Order implements Comparator<Object>` as its now generalized to multiple types of objects.
* The `maxContentLength` setting in Gremlin Server is now respected by the HTTP/REST Gremlin endpoint.
* Fixed resource leak in the HTTP/REST Gremlin endpoint of Gremlin Server.
* Refactored Gremlin Server `start` and `stop` functions to return `CompletableFuture`.
* HTTP REST error response JSON objects from Gremlin Server should no longer have issues with control characters, line feeds, etc.
* Added `MeanStep`, `mean()`, and `MeanNumber` for calculating number averages in a traversal.
* Greatly simplified all the traversal `MapReduce` implementations due to the introduction of `VertexTraversalSideEffects`.
* Added `VertexTraversalSideEffects` as a cheap, static way to get a sideEffect-view of a vertex in OLAP.
* Added `TraversalHelper.isLocalStarGraph()` which determines if a traversal is contained within the local star graph.
* Added `TraversalVerificationStrategy` to verify if the traversal can be executed on respective engine.
* Refactored `GraphTraversal.cap()` to `GraphTraversal.cap(String...)` to support multi-sideEffect grabs.
* Added GraphSON serialization for `Path`.
* Added `Traversal.Admin.getTraverserRequirements()` and removed `TraversalHelper.getTraverserRequirements(Traversal)`.
* `Traversal.equals()` is no longer computed by determining if the objects returned are equal.
* Altered messaging in Gremlin Console when using a remote that is not yet activated.
* Fixed potential for deadlock in Gremlin Driver when waiting for results from the server.
* Added the `useMapperFromGraph` serializer option to the Gremlin Server configuration file to allow auto-registration of serialization classes.
* Refactored Netty pipeline structure to not have a second "Gremlin" executor group and instead used a standard `ExecutorService`.
* Refactored the `GremlinExecutor` to take an optional transformation function so as to allow manipulation of results from `eval` in the same thread of execution.
* Fixed issue with the `HttpGremlinEndpointHandler` where requests were getting blocked when `keep-alive` was on.
* Added `MinStep` and `MaxStep` with respective `min()` and `max()`.
* `CountStep` and `SumStep` now extend `ReducingBarrierStep` and no longer are sideEffect steps.
* `SideEffectCapStep` now extends `SupplyingBarrier` and is much simpler than before.
* Added `SupplyingBarrier` which simply drains the traversal and emits the value of a provided supplier.
* Added `TraversalLambda` which implements function, predicate, and consumer over a provided traversal.
* Any non-core `Step` that takes a function or predicate can now take a traversal which maps to `traversal.next()` (function) and `traversal.hasNext()` (predicate).
* `CollectingBarrierStep` is no longer abstract and added `GraphTraversal.barrier()` which is analogous to `fold().unfold()`, though cheaper.
* Added `TraversalOptionHolder` for branching steps to index works with corresponding `GraphTraversal.option()`.
* `BranchStep` is now a proper generalization of `UnionStep` and `ChooseStep`.
* `SubgraphStep` has changed in support of in-traversal filtering and removing the need for path-based traversers.
* Added `HasTraversalStep` which takes an anonymous traversal to determine whether or not to filter the current object.
* Added `Traversal.Admin.getStartStep()` and `Traversal.Admin.getEndStep()`. Removed `TraversalHelper.getStart()` and `TraversalHelper.getEnd()`.
* Refactored `profile()` to use injected steps. `ProfileStep` can now be used without any special JVM command line parameters.
* Added `ReducingBarrierStep` which acts like `CollectingBarrierStep` but operates on a seed with a bi-function.
* Added a preprocessor for AsciiDocs. Documentation code examples are executed and the results are dynamically inserted into the doc file.
* `LocalStep` traversal is treated as a branch, not an isolated traversal. Moreover, moved `LocalStep` to `branch/`.
* Traversal strategies are now applied when the `TraversalVertexProgram` state is loaded, not when submitted. Less error prone as it guarantees strategy application.
* Reworked `TraversalHolder` where there are "local traversals" and "global traversals". Local traversals are not subject to OLAP message passing.
* Fixed a bug in `DedupStep` that made itself apparent in `DedupOptimizerStrategy`.
* Added `RepeatStep.RepeatEndStep` in order to reduce the complexity of the code on OLAP when the predicates are not at the start of `RepeatStep`.

TinkerPop 3.0.0.M7 (Release Date: January 19, 2015)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Added `SideEffectRegistrar` interface and `SideEffectRegistrationStrategy` for allowing steps to register sideEffects at strategy application time.
* Renamed `Traverser.Admin.setFuture()` and `Traverser.Admin.getFuture()` to `setStepId()` and `getStepId()`, respectively.
* Added `TraversalMatrix` for random access to steps in a traversal by their step id. Used by `TraversalVertexProgram`.
* Added unique identifies to `Step` that are not the user provided labels. `Step.getLabel()` now returns an `Optional<String>`.
* Removed `UnionLinearStrategy`, `ChooseLinearStrategy`, and `RepeatLinearStrategy` as nested traversals are now natively supported in OLAP.
* Fixed `Neo4jGraph` around manual transaction behavior on `commit` and `rollback` such that they would throw exceptions if a transaction was not open.
* Redesigned the hidden step labeling mechanism so its consistent across a cluster, easier for rewrite strategies, and will enable nested OLAP traversals.
* `Traverser.incrLoops()` now takes a string step label to enable nested looping constructs (i.e. loop stacks).
* Added `Traversal.tryNext()` which returns an `Optional`, where the provided default method should be sufficient for all vendors.
* Removed `PathConsumer` in favor of `TraverserRequirement.PATH`-model via `Step.getRequirements()`.
* `Step.getRequirements()` returns a `Set<TraverserRequirement>` which is what is required of the `Traverser` by the `Step`.
* `Traverser` now extends `Cloneable` and `Traverser.clone()` is used to good effect in `Traverser.split()`.
* Added `AbstractTraverser` for which all traversers extend.
* Moved `Traversal.SideEffects` to `TraversalSideEffects` as sideEffects are not necessarily tied to the traversal.
* Removed `Graph.of()` for generating anonymous graph traversals -- replaced by `__`-model.
* Removed `Graph` being stored in `Traversal.SideEffects`. Too dangerous when moving between OLTP and OLAP and its limited uses were worked around easily.
* No need for `DefaultXXXGraphTraversal` unless the vendor is extending with new methods (e.g. `DefaultNeo4jGraphTraversal`).
* Reworked `TraversalStrategies` such that the are "emanating object class"-dependant, not `Traversal` dependent.
* Moved `Traverser.sideEffects()` to `Traverser.asAdmin().getSideEffects()`. Users should use `Traverser.sideEffects(key)` and `Traverser.sideEffects(key,value)`.
* Added `SerializationTest` to the `StructureStandardSuite` in `gremlin-test` which validates serialization at a lower level than `IoTest`.
* Removed `IntervalStep` and renamed `interval()` to `between()` which is simply an alias to a `has().has()` chain.
* Added `__` static interface which allows for `__.out().out()`-style construction of anonymous traversals (instead of `g.of()`).
* The only `GraphTraversal` steps that operate on `Traverser` are the base lambdas and `repeat()` (i.e. `emit()` and `until()`).
* Removed dependency on the `reflections` library in `gremlin-test` which removed the default implementation of `GraphProvider.getImplementations()` - vendors now need to implement this method themselves.
* Relaxed the `<S>` typing requirement for anonymous traversals when applied to `choose()`, `repeat()`, `union()`, etc.
* Removed `LoopStep` and `UntilStep` in favor of the new `RepeatStep` model of looping in Gremlin3.
* `BranchStep` is now exposed in `GraphTraversal` via `branch(function)`.
* `UnionStep` now implements `TraversalHolder`.
* Added `RepeatStep` as the new looping construct supporting do/while, while/do, and emit semantics.
* Moved `Traversal.sideEffects()` to `Traversal.Admin.getSideEffects()` as `cap()` should be used to access the sideEffect data of a traversal.
* Renamed vendor `XXXTraversal` to `XXXGraphTraversal` (interface) and `XXXGraphTraversal` to `DefaultXXXGraphTraversal` (implementation class).
* Modified packaging for console plugins to be more consistent by moving them to the `com.tinkerpop.gremlin.console.groovy.plugin` namespace.
* Removed all TinkerPop specific dependencies to Guava to avoid user version conflicts.
* Added support for `-e` (script file execution) and `-v` (version display) options on `gremlin.sh`.
* GraphSON supports the assignment of multiple custom serialization modules.
* `Traverser.get(stepLabel/sideEffectKey)` no longer exists. There now exists: `Traverser.path(stepLabel)` and `Traverser.sideEffects(sideEffectKey)`.
* `SimpleTraverser` now supports "path" but in a very loose, global cache way. Added `SparsePath` as a `Map`-backed `Path` implementation.
* Provided Neo4j multi-label support in Neo4j-Gremlin. Added three `Neo4jVertex`-specific methods: `addLabel()`, `removeLabel()`, `labels()`.
* Bumped to Groovy 2.3.9.
* Added `Graph.Io` interface which allows for simplified helper methods for end users and a way for vendors to override `GraphReader` and `GraphWriter` initial construction when custom serializers are needed.
* Removed methods from `GraphProvider` related to customizing serializers in `IoTest` from the test suite as the new `Graph.Io` interface now serves that purpose.
* Added `Neo4jGraph.checkElementsInTransaction(boolean)` which will (or not) verify whether elements retrieved via Neo4j global graph operations are transactionally consistent.
* Added `ScriptInputFormat` and `ScriptOutputFormat` to Hadoop-Gremlin for reading and writing a file according to an arbitrary parsing script.
* Added `TimeLimitStep.getTimedOut()` to determine if the step timed out or there were no more objects to process.
* `Graph.System` is now `Graph.Hidden` with "hidden" being the vendor namespace and the key prefix being `~`.
* Much better `toString()` handling in `Step` and `Traversal`.
* `ComparatorHolder<V>` interface returns a `List<Comparator<V>>` instead of a `Comparator<V>[]`.
* `T` now implements `Function<Element,Object>`.
* Added `ElementValueComparator` and `ElementFunctionComparator` in support of vendor introspection on `ComparatorHolder`-steps.
* Renamed `Comparing` marker interface to `ComparatorHolder`.
* `FunctionHolder` interface provides vendor introspection via `ElementValueFunction`.
* Removed `OrderByStep` as it is now just `order()` with a `by()`-based comparator.
* Added `SampleStep` (`sample()`) to allow for sampling the set of previous objects. Useful for doing random walks with `local()`.
* Renamed `random()` to `coin()` to better express that the filter is a random coin toss.
* Added `by()`-projection to modulate the meaning of post-processing steps like `aggregate()`, `groupCount()`, `path()`, `order()`, etc.
* Removed the `Strategy` interface and gave `StrategyGraph` direct access to the `GraphStrategy`.
* Added `Graph.strategy()` to help instantiate `StrategyGraph` instances.
* Modified the signature of all `GraphStrategy` methods to include an parameter that contains a reference to the "composing strategy".
* `PartitionStrategy` hides the specified partition key from view when iterating properties, keys, etc.
* Change construction of `GraphStrategy` implementations to be consistent with singleton instances and builder pattern.
* Added `Graph.Helper` annotation to "protected" certain default interface methods from implementation by vendors.
* Transaction retry functions now work with "manual" transactions.
* Improved error messaging when importing "legacy" GraphSON that was not generated with "extended" properties.
* Renamed "iterator" related methods in the `GraphStrategy` interface to be consistent with the method names they represent.
* `PropertyMapStep` (`valueMap()`) now takes a boolean to state if the tokens of the element are desired along with its properties.
* `HadoopGraph` now connected to the `StructureProcessSuite`.
* `HadoopGraph` no longer supports `Graph.Variables` as they were in-memory. A persistence mechanism can be introduced in the future.
* Hidden properties removed in favor of using `GraphStrategy` for such features.
* `Edge.iterators().vertexIterator(BOTH)` now guarantees `OUT` then `IN` vertex iterator order.
* `Graph.v(Object)` and `Graph.e(Object)` no longer exist. Instead, use `Graph.V(Object... ids)` and `Graph.E(Object... ids)`.
* Added `Graph.Iterators` to allow access to vertex and edge iterators based on element ids and bypassing `GraphTraversal`.
* Renamed `GraphStrategy` implementations to be less verbose - removed the word "Graph" from their names (e.g. `IdGraphStrategy` simply changed to `IdStrategy`).
* Removed `Step.NO_OBJECT` as the problem is solves can be solved with proper use of `flatMap` and `EmptyTraverser`.
* `Path` is now part of `GraphSerializer` and thus, not specific to a particular implementation of `Path`.
* Added messaging to show files being downloaded when using the Gremlin Server "install" command.
* Added test name and class arguments to the `GraphProvider.loadGraphWith` method.
* Merged `ReferencedXXX` and `DetachedXXX` so that all migration of graph element data is via `DetachedXXX`.
* Added `StaticVertexProgram` and `StaticMapReduce` which simply return `this` on `clone()`.
* `VertexProgram` and `MapReduce` now implement `Cloneable` and is used for fast copying across workers within the same machine.
* Added `TraversalHolder` interface which extends `PathConsumer` to determine recursively if nested traversals require path calculations turned on.
* Reworked how a `TraverserGenerator` is retrieved and utilized.
* Added `Traversal.toBulkSet()` to make getting resultant data more efficiently for traversals with repeated data.
* Provided a helper `LocalStep.isLocalStarGraph()` so `GraphComputer` implementers know the requisite data boundaries.
* Created `Traversal.Admin` to hide administrative methods. Added `Traversal.asAdmin()` to get at `Traversal.Admin`.
* Fixed up all `Step` cloning operations realizing that Java8 lambdas are always bound to the calling class (no delegates).
* Usage of `:remote close` without configured remotes shows a reasonable message rather than a stack trace.
* Provided `LocalStep` to signify that the internal traversal is locally bound to the incoming object.
* Failed script evaluation in Gremlin Server now triggers the cancel of the process attempting to timeout the script if it were to run too long.
* Greatly increased the speed of `ScriptEngineLambda` by making use of a static `ScriptEngine` cache.
* Fixed a general bug in all sideEffect using steps where the sideEffect should be accessed via the `Traverser` not `Traversal`.
* `GremlinPlugin` interface no longer has the `additionalDependencies` method - those dependencies are now defined by an entry in the manifest file for the jar called `Gremlin-Plugin-Dependencies`.
* Added `TinkerWorkerPool` which is used for resource efficient threading in `TinkerGraphComputer`.
* `MapReduce.createMapReduce(Configuration)` now exists and serves the same purpose as `VertexProgram.createVertexProgram(Configuration)`.
* Enabled SessionOps to be extended. Added eval handler hook.
* Setting a property with an unsupported data type throw `IllegalArgumentException` instead of `UnsupportedOperationException` as the operation is supported, but the argument is not.

TinkerPop 3.0.0.M6 (Release Date: December 2, 2014)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* `javatuples.Pair` avoided on `MapReduce` API in favor of a new `KeyValue` class.
* Renamed `Gremlin-Plugin` manifest entry for plugins to `Gremlin-Plugin-Paths`.
* Added `Gremlin-Plugin-Dependencies` manifest entry to list other dependencies that should be retrieved with a plugin jar.
* `Memory.Admin.asImmutable()` yields an immutable representation of the GraphComputer `Memory`.
* Fixed host selection in `gremlin-driver` by properly accounting for all hosts being marked unavailable at the instantiation of a `Client`.
* Removed Giraph-Gremlin in favor of new Hadoop-Gremlin with `GiraphGraphComputer` support. Future support for `MapReduceGraphComputer`.
* Greatly simplified the `InputFormat` and `OutputFormat` model for working with Giraph (and Hadoop).
* Added a serializer for `Property` for GraphSON correcting format of serialization of a single `Property` on an `Edge`.
* Fixed bug in Gremlin Console that prevented assignments to empty `List` objects.
* Added `VertexProgram.getMessageScopes()` to allow vendors to know which `MessageScopes` at a particular `Memory` state.
* Reduced the number of methods in `MessageScope.Local` as its up to vendors to inspect provided incident `Traversal` accordingly.
* Renamed `MessagesType` to `MessageScope` to make it less ambiguous regarding the class of the messages being sent.
* Changed the message type of `TraversalVertexProgram` to `TraverserSet` to support message combining.
* Added `VertexProgram.getMessageCombiner()` to support the combining of messages in route to a vertex.
* Reduced object creation in `TraversalVertexProgram` around vertex-local traversal sideEffects.
* Renamed `Traverser.Admin.makeChild()` and `Traverser.Admin.makeSibling()` to `Traverser.Admin.split()` to correspond with `merge()`.
* Added `Traverser.Admin.merge(Traverser)` method so that the merging algorithm is with the `Traverser`.
* Added `Operator` enum that contains sack-helpful `BinaryOperators`: sum, minus, mult, div, max, min, etc.
* Added `GraphTraversal.withSack()` and renamed `trackPaths()` and `with()` to `withPath()` and `withSideEffect()`, respectively.
* Added the "Gremlin Sacks" feature to allow a `Traverser` to carry local information along its walk.
* GraphSON format no longer makes use of `hiddens` JSON key. Its all just `properties`.
* Added `DoubleIterator` to make vendor implementations of `Edge.iterators().vertexIterator()` efficient.
* `PropertiesStep` is smart about hiddens vs. properties.
* `Element.iterators().hiddenProperties()` no longer exists. For vendors, simply provide an iterator of properties.
* `GIRAPH_GREMLIN_LIBS` supports colon separated directories for loading jars from multiple paths.
* Introduced method to control the location of dependencies dynamically loaded to the Gremlin Console as part of the `:install` command.
* Fixed problem with the Neo4j Gremlin Plugin not loading properly after Gremlin Console restart.
* Removed the "use" configuration from Gremlin Server.
* Moved `SugarGremlinPlugin` from `gremlin-console` to `gremlin-groovy` so that it could be shared with Gremlin Server.
* Fixed bug in serialization of `null` results returned to the Gremlin Console when serializing to strings.
* Moved the `GremlinPlugin` for `TinkerGraph` to `tinkergraph-gremlin` module (it is no longer in `gremlin-console`).
* Added a `plugin-info.txt` file to Gremlin Console `/ext/{module}` subdirectories to identify the module that was originally requested.
* Gremlin Server now allows for the explicit configuration of plugin activation.
* Refactored `GremlinPlugin` and `AbstractGremlinPlugin` to better account for plugins that run on the server and those that run in the console.
* Added a `plugins` configuration to Gremlin Server to control the plugins that are enabled on initialization.
* Added a builder option to `GremlinExecutor` to control the plugins that are enabled on initialization.
* Added `RemoteException` for usage with `RemoteAcceptor` implementations for the Gremlin Console so as to better standardize their development.
* Standardized all text being written to the Gremlin Console using starting upper case letter.
* Prevented error in the Console when `:submit` is called but no remotes were configured.
* Provided a way to clean the `grapes` directory as part of a standard build with `mvn clean install`.

TinkerPop 3.0.0.M5 (Release Date: November 7, 2014)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Removed `PropertyFilterIterator` as using Java8 streams was just as efficient for the use case.
* Renamed `KryoWritable` to `GremlinWritable` as it is not necessarily Kryo that is the serialization mechanism.
* Fixed an input split bug in Giraph that was making it so that splits were not always at vertex boundaries.
* Fixed a combiner bug in `GirapGraphComputer`. Combiners were always calling `MapReduce.reduce()`, not `MapReduce.combine()`.
* Greatly simplified `SubgraphStrategy` by removing requirements for `Traversal` introspection.
* `StrategyWrappedGraph` mimics vendor use of `GraphStep` and `GraphTraversal` and no longer requires dynamic strategy application.
* `TraversalStrategies` make use of a dependency tree sorting algorithm to ensure proper sorts prior to application.
* `TraversalStrategies` are now immutable and are bound to the `Traversal` class.
* Fixed bug in Gephi Plugin that prevented it from communicating with the Gephi Streaming Server.
* Renamed `MessageType.XXX.to()` to `MessageType.XXX.of()` so it makes sense in both the sending and receiving context.
* Improved messaging with respect to tests that are ignored due to features to make it clear that those tests are not in error.
* Relaxed exception consistency checks in the test suite to only check that a thrown exception from an implementation extends the expected exception class (but no longer validates that it is the exact class or that the message text).
* `VertexProgram` now has `workerIterationStart()` and `workerIterationEnd()` to allow developers to control vertex split static data structures.
* `TraversalVertexProgram` startup time greatly reduced due to being smart about `loadState()` behavior.
* Gremlin Server sessions now allow serialization of results that were part of an open transaction.
* Refactor `OpProcessors` implementations in Gremlin Server for better reusability.
* `Vertex.iterators()` no longer have a `branchFactor`. This is now at the query language level with `localLimit()`.
* Added `limit(long)` and `localLimit(int,int)` which simply call the range equivalents with 0 as the low.
* Added `LocalRangeStep` which supports ranging the edges and properties of an element -- `localRange(int,int)`.
* `GraphTraversal.value(String)` no longer exists. Instead, use `GraphTraversal.values(String)`.
* `HiddenXXXStep` and `ValueXXXStep` no longer exist. `PropertyXXXStep` takes a `PropertyType` to denote value and hidden access.
* Added `PropertyType` to the structure-package which provide markers for denoting property types (vs. property classes).
* Renamed `setWorkingDirectory` to `workingDirectory` in the `KryoReader` builder.
* `Path.get(String)` returns the object if only one object is referenced by label, else it returns a `List` of referenced objects.
* Added overload to `GremlinKryo` to allow a serializer to be configured as a `Function<Kryo,Serializer>` to allow better flexibility in serializer creation.
* Added method to `GraphProvider` to allow implementers to provide a mechanism to convert GraphSON serialized identifiers back to custom identifiers as needed.
* Added methods to `GraphProvider` so that implementers could specify a custom built `GremlinKryo` class and/or `SimpleModule` class in case their implementation had custom classes to be serialized.
* Added `Traversal.forEachRemaining(class,consumer)` for those traversals whose end type is different from declared due to strategy rewriting.
* Removed `Traversal.forEach()` as traversal implements `Iterator` and users should use `forEachRemaining()`.
* `RangeStep` now has an inclusive low and an exclusive high -- a change from Gremlin2.
* `DriverGremlinPlugin` returns raw results with driver results available via the `result` variable.
* Removed test enforcement of `private` constructor for a `Graph` instance.
* `RemoteAcceptor` now supports `@` prefixed lines that will grab the script string from the Gremlin Console shell.
* Modified the signature of `Property.element()` to simply return `Element`
* Added `Reducing` marker and `ReducingStrategy` which supports reduction-functions as a final step in Gremlin OLAP (e.g. `fold()`).
* Once strategies are `complete()`, no more steps can be added to a `Traversal`.
* Renamed `Traversal.strategies()` to `Traversal.getStrategies()` as it is not a "query language"-method.
* Added test to enforce that a `label` on a `VertexProperty` is always set to the key of the owning property.
* Fixed bug with multi-property removal in `Neo4jGraph`.
* Bumped to Neo4j 2.1.5.
* Used standard `UUIDSerializer` from the `kryo-serializers` library for serialization of `UUID` objects.
* Changed GraphSON serialization to only use `iterators()` - there were still remnants of `Traversal` usage from previous refactoring.
* Added overload for `detach` method to allow for the `Element` to be detached as a "reference" only (i.e. without properties).
* Renamed `Item` in `gremlin-driver` to `Result`.
* Renamed `strategy` to `getStrategy` in `StrategyWrappedGraph`.
* Renamed `baseGraph` to `getBaseGraph` in `Neo4jGraph`.
* `Neo4jGraph` now returns an empty property `Vertex.property(k)` when the key is non-existent (a problem only visible when meta/multi property configuration was turned off).
* `Traversal.Strategies.apply()` now takes a `TraversalEngine`. Greatly simplifies strategy application for `STANDARD` or `COMPUTER`.
* Renamed `IdentityReductionStrategy` to `IdentityRemovalStrategy` for reasons of clarity.
* Added `ComparingRemovalStrategy` that removes `Comparing`-marked steps unless they are the end step of the traversal.
* `OrderStep` now works in OLAP, but only makes sense as a traversal end step.
* `MapReduce` API extended to include `getMapKeySort()` and `getReduceKeySort()` to sort outputs accordingly.
* Renamed `TraversalResultMapReduce` to `TraverserMapReduce`. Shorter and makes more sense.
* Improved build automation to package javadocs and asciidoc documentation in the distribution files.
* Improved build automation with a script to automatically bump release versions in the various files that needed it such as the `pom.xml` files.
* The identifier on `VertexProperty` is now read properly to those graphs that can support identifier assignment.
* `GraphSONReader.readGraph()` now properly reads vertex properties.
* Removed `Neo4jGraph.getCypher()` as users should use `Neo4jGraph.cypher()` and get back TinkerPop3 graph objects.
* `GiraphGraph.variables().getConfiguration()` is now replaced by `GiraphGraph.configuration()`.
* Added `Graph.configuration()` which returns the `Configuration` object of `Graph.open()`.
* Removed `TraverserTracker` as now there is only a `TraverserSet` for all halted traversers. A nice simplification of `TraversalVertexProgram`.
* Renamed `Traverser.isDone()` to `Traverser.isHalted()` and `DONE` to `HALT`. Consistent with automata terminology.
* Removed `PathTraverserExecutor` and `SimpleTraverserExecutor` as a single `TraverserExecutor` correctly executes both types of traversers.
* `TraversalVertexProgram` does "reflexive message passing" to reduce the total number of iterations required to execute a traversal.
* `MapReduce` no-argument constructors are private and thus, only for reflection and `loadState()` usage.
* MapReducers for `TraversalVertexProgram` are now smart about `with()` declared data structures.
* Updated `Traversal.SideEffects` to use "registered suppliers" and it now works accordingly in both OLTP and OLAP environments.
* Increased the speed of `FlatMapStep` by approximately 1.5x.

TinkerPop 3.0.0.M4 (Release Date: October 21, 2014)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Added features for `VertexProperty` user supplied ids and related data types.
* Removed `SideEffectCap` marker interface as there is only one `SideEffectCapStep` and thus, `instanceof` is sufficient.
* `Path.getObjects()`/`Path.getLabels()` renamed to `Path.objects()`/`Path.labels()` to be in line with "query language" naming convention.
* Greatly simplified `GiraphInternalVertex` due to `Element.graph()` -- 1/2 the memory footprint and reduced construction time.
* Renamed `Property.getElement()` to `Property.element()` given the "query language" naming convention.
* `Element.graph()` added which returns the `Graph` that the element is contained within.
* Added tests for greater consistency around iterating hidden properties.
* Simplified `TraversalVertexProgram` where only a single `TraverserTracker` exists for both path- and simple-traversers.
* Fixed a major bug where `Arrays.binarySearch` was being used on an unsorted array in TinkerGraph and Neo4jGraph.
* Changed `ComputerResult.getXXX()` to `graph()` and `memory()` to be consistent with "query language" naming convention.
* `Traverser.getXXX()` changed to `loops()`, `bulk()`, `path()`, `sideEffects()` to be consistent with "query language" naming convention.
* Optimization to reduce the number of empty lists created due to no step class existing for respective `TraversalStrategy.apply()`.
* Added `CapTraversal` as a marker interface for the `cap()` method.
* Added `union()` with GraphComputer `UnionLinearStrategy`.
* `TimeLimitStep` was moved to `filter/` package. It was a mistake that it was in `sideEffect/`.
* Provided the configuration for generating both a "full" and "core" set of javadocs, where "full" represents all classes in all projects and "core" is the "user" subset.
* Validated bindings passed to Gremlin Server to ensure that they do not match the most common statically imported values.
* If no script engine name is provided to a `LambdaHolder` it is assumed to be Gremlin-Groovy.
* `MapEmitter` and `ReduceEmitter` have an `emit(value)` default method where the key is the `MapReduce.NullObject` singleton.
* `Traverser.Admin` now implements `Attachable` as the `Traversal.SideEffects` can be generated from the `Vertex`.
* Made a solid effort to ensure that all TinkerPop keys are `Graph.System` to leave `Graph.Key` for users.
* The `Graph.System` prefix is now `^` instead of `%&%`. Simpler and easier on the `toString()`-eyes.
* Added `Traversal.SideEffects.ifPresent(Consumer)` as a default helper method.
* Added `profile()`-step which provides detailed information about the performance of each step in a traversal.
* No more `CountCapStep` and `CountStep`, there is only `CountStep` and it is elegant.
* Created a `AbstractTraversalStrategy` with good `toString()`, `hasCode()`, and `equals()` implementations.
* Added `CountTraversal` as a marker-interface stating that the `Traversal` has a `count() -> Long` method.
* `Traversal` no longer has any step methods as its not required for DSL implementers to have "core steps."
* Added "linearization" strategy for `ChooseStep` so it is executed correctly on GraphComputer.
* Added ``GraphTraversalStrategyRegistry` which has respective global strategies to make turning on/off strategies easier.
* Added a generic `BranchStep` to be used for re-writing "meta-steps" for execution on GraphComputer.
* Moved `JumpStep`, `UntilStep`, and `ChooseStep` to a new `branch/` package.
* Added test cases to the Structure Suite to enforce consistent operations of reading properties after removal of their owning `Element`.
* GraphSON format change for full `Graph` serialization - Graph variables are now serialized with the key "variables" as opposed to "properties".
* Relaxed `Graph.toString()` test requirements for implementers.
* Made the `toString` operations in `GraphStrategy` consistent.
* Added `VertexFeatures.supportsRemoveProperty`.
* Added `VertexPropertyFeatures.supportsRemoveProperty`.
* Added `EdgeFeatures.supportsRemoveProperty`.
* Added `VertexFeatures.supportsRemoveVertices`.
* Added `EdgeFeatures.supportsRemoveEdges`.
* Vendors should now get a clear error when mis-spelling something in an `@OptOut` (or more likely if a test name changes) and it now works all the test suites.
* All plugins now have a default prefix of "tinkerpop." as a namespace.
* `GraphComputer` now executes a `Set<MapReduce>` and `hashCode()`/`equals()` were implemented for existing `MapReduce` implementations.
* Changed `Contains.in/notin` to `Contains.within/without` as `in` is a reserved term in most languages (including Java and Groovy).
* Added helper methods for loading data into collections in `TraversalHelper`.
* Core `Traversal` methods are smart about bulking -- e.g. `iterate()`, `fill()`, `remove()`, etc.
* `GroupByStep` and `GroupByMapReduce` leverage `BulkSet` as the default group data structure.
* `Element.Iterator` has renamed methods so implementers can do `MyElement implements Element, Element.Iterators`.
* Renamed `MessageType.Global` and `MessageType.Local` creators from `of()` to `to()` as it makes more sense to send messages `to()`.
* With `Traverser.get/setBulk()` there is no need for a `TraverserMessage`. The `Traverser` is now the message in `TraversalVertexProgram`.
* Provided static `make()` methods for constructing `Path` implementations.
* Provided a more space/time efficient algorithm for `Path.isSimple()`.
* The `JumpStep` GraphComputer algorithm `Queue` is now a `TraverserSet`.
* `AggregateStep` and `StoreStep` now use `BulkSet` as their default backing `Collection` (much more space/time efficient).
* Added `BulkSet` which is like `TraverserSet` but for arbitrary objects (i.e. a weighted set).
* `UnrollJumpStrategy` is no longer a default strategy as it is less efficient with the inclusion of `TraverserSet`.
* Introduced `TraverserSet` with bulk updating capabilities. Like OLAP, OLTP looping is now linear space/time complexity.
* TinkerGraph's MapReduce framework is now thread safe with a parallel execution implementation.
* Added a default `Traverser.asAdmin()` method as a typecast convenience to `Traverser.Admin`.
* Renamed `Traverser.System` to `Traverser.Admin` as to not cause `java.lang.System` reference issues.
* Renamed `Memory.Administrative` to `Memory.Admin` to make it shorter and consistent with `Traverser.Admin`.
* Fixed a TinkerGraph bug around user supplied vertex property ids.
* Most `Step` classes are now defined as `public final class` to prevent inheritance.
* `ShuffleStep` now extends `BarrierStep` which enables semantically correct step-sideEffects.
* Leveraged `Traverser.getBulk()` consistently throughout all steps.

TinkerPop 3.0.0.M3 (Release Date: October 6, 2014)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* All `Step` fields are now `private`/`protected` with respective getters as currently needed and will be added to as needed.
* Gremlin Server no longer has the `traverse` operation as lambdas aren't really serialized.
* `Path` is now an interface with `ImmutablePath` and `MutablePath` as implementations (2x speedup on path calculations).
* `Traverser` now implements `Comparable`. If the underlying object doesn't implement `Comparable`, then a runtime exception.
* Added abstract `BarrierStep` which greatly simplifies implementing barriers like `AggregateStep`, `OrderStep`, etc.
* `SelectStep` is now intelligent about when to trigger path computations based on label selectors and barriers.
* `T` no longer has `eq`, `neq`, `lt`, `in`, etc. Renamed all respective enums and with `static import`, good in console (e.g. `Compare.eq`).
* Added `Order` enum which provides `Order.decr` and `Order.incr`.
* `Traverser.loops` and `Jump.loops` are now shorts (`32767` max-loops is probably sufficient for 99.9999% of use cases).
* `Traverser.bulk` exists which is how many instances does the traverser represent. For use in grouping with bulk computations.
* Greatly simplified sideEffect steps where there is no distinction between OLAP vs. OLTP (from the `Step` perspective).
* Removed the need for `Bulkable` and `VertexCentric` marker interfaces in process API.
* Renamed configuration parameters in Giraph-Gremlin to be consistent with a `giraph.gremlin`-prefix.
* Made it possible to pass a `ScriptEngine` name and string script in `TraversalVertexProgram` and `LambdaVertexProgram`.
* Made `TinkerGraph` a plugin for the Console as it is no longer a direct dependency in `gremlin-groovy`.
* Added features for supporting the addition of properties via `Element.property(String,Object)`.
* `GiraphGraph` OLTP tested against Gremlin-Java8 and Gremlin-Groovy -- OLAP tested against Gremlin-Groovy.
* `Neo4jGraph` is now tested against both Gremlin-Java8 and Gremlin-Groovy.
* Renamed the test cases in `ProcessTestSuite` to be consistent with other Gremlin language variants.
* Added a `gremlin-groovy-test` suite that can be used to validate implementations against the Groovy variant of Gremlin.
* `TinkerGraph` is no longer serializable, use a `GraphReader`/`GraphWriter` to serialize the graph data.
* Removed `implements Serializable` on numerous classes to ensure safety and proper usage of utilities for cloning.
* `Traversal` now implements `Cloneable` as this is the means that inter-JVM threads are able to get sibling `Traversals`.
* Created "integration" test for `Neo4jGraph` that runs the test suite with multi/meta property features turned off.
* Added `GraphStrategy` methods for `VertexProperty`.
* Converted the `id` data type from string to integer in the Grateful Dead sample data.
* Removed all notions of serializable lambdas as this is a misconception and should not be part of TinkerPop.
* Greatly simplified `TraversalVertexProgram` with three arguments: a `Traversal<Supplier>`, `Class<Traversal<Supplier>>`, or a script string with `ScriptEngine` name.
* Added `TraversalScript` interface with `GroovyTraversalScript` as an instance. To be used by OLAP engines and any language variant (e.g. gremlin-scala, gremlin-js, etc.).
* `UntilStep` now leverages `UnrollJumpStrategy` accordingly.
* Fixed a bug where the `toString()` of `Traversal` was being hijacked by `SugarGremlinPlugin`.
* Fixed compilation bug in `UntilStep` that is realized when used in multi-machine OLAP.
* Simplified `Enumerator` and implementations for `MatchStep`.

TinkerPop 3.0.0.M2 (Release Date: September 23, 2014)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Added an exhaust `InnerJoinEnumerator` fix in `MatchStep` to get all solutions correctly.
* `Neo4jGraph` can be configured to allow or disallow meta- and multi-properties.
* Added `until()`-step as a simpler way to express while-do looping which compiles down to a `jump()`-step equivalent.
* Added "The Crew" (`CREW`) toy graph which contains multi-properties, meta-properties, graph variables, hiddens, etc.
* If the Giraph job fails, then the subsequent `MapReduce` jobs will not execute.
* Added `Graph.System` class which generates keys prefixed with `%&%` which is considered the vendor namespace and not allowed by users.
* Added `ReferencedVertex` (etc. for all graph object types) for lightweight message passing of graph object ids.
* `T.*` now has `label`, `id`, `key`, `value` and no longer are these `String` representations reserved in TinkerPop.
* `Traverser` now has a transient reference to `Traversal.SideEffects`.
* "Detached" classes are now tested by the standard test suite.
* Compartmentalized `Traverser` interface so there is now a `Traverser.System` sub-interface with methods that users shouldn't call.
* Added `OrderByStep` which orders `Elements` according to the value of a provided key.
* 2x speed increase on steps that rely heavily on `ExpandableStepIterator` with massive memory footprint reduction as well.
* Added `VertexProperty<V>` as the property type for vertices -- provides multi-properties and properties on properties for vertices.
* Changed `VertexProgram` such that `getElementComputeKeys()` is simply a `Set<String>`.
* Significant changes to the format of the `ResponseMessage` for Gremlin Server - these changes break existing clients.
* Close any open transactions on any configured `Graph` when a session in Gremlin Server is killed.
* Grateful Dead Graph now uses vertex labels instead of "type" properties.
* There is now a `GraphComputerStrategy` and `EngineDependent` marker interface to allow steps to decide their algorithm depending if they are OLAP or OLTP.
* A labeled step now stores its current traverser value in `Traversal.SideEffects` (no longer can sideEffectKeys and step labels be the same).
* `GraphFactory` support for opening a `Graph` with multiple `GraphStrategy` instances - if there are multiple strategies they are wrapped in order via `SequenceGraphStrategy`.
* The result type for result termination messages returned from Gremlin Server is now set to "no content".
* The `maxContentLength` setting for Gremlin Driver now blocks incoming frames that are too large.
* After initialization scripts are executed in Gremlin Server, the `Graph` instances are re-bound back to their global references, thus allowing `GraphStrategy` initialization or even dynamic `Graph` creation through scripts.
* Added "Modern" graph back which is basically the "Classic" graph with double values for the "weight" property on edges and non-default vertex labels.
* `Traversal.addStep()` is now hard typed so type casting isn't required and traversal APIs look clean.
* Changed the hidden key prefix from `%$%` to `~` in `Graph.Key.hide()`.
* Added `has(label,key,predicate,value)` to allow for `has('person','name','marko')`. Various overloaded methods provided.
* Update to traversal API where if a `SFunction<S,?>` was required, but can process a `Traverser<S>`, then the function is `SFunction<Traverser<S>,?>`.
* Added `WhereStep` as a way to further constrain `select()` and `match()`.
* Extensive work on `GiraphMemory` and its interaction with Giraph aggregators.
* If the input path of a `GiraphGraphComputer` does not exist, failure happens prior to job submission.
* `SugarPlugin` now has all inefficient methods and Gremlin-Groovy proper is only efficient Groovy techniques.
* Prevented concurrency problems by only modifying bindings within the same thread of execution in the `GremlinExecutor`.
* Calls to `use` on the `DependencyManager` now return the list of `GremlinPlugin` instances to initialize instead of just initializing them automatically because it causes problems with `ScriptEngine` setup if a plugin requires a script to be evaluated and a required dependency is not yet loaded.
* `Traversal.SideEffects` has `getGraph()`, `setGraph()`, and `removeGraph()` default helpers.
* `Traversal.Memory` -> `Traversal.SideEffects` and `GraphComputer.SideEffects` -> `GraphComputer.Memory`.
* `StrategyWrappedVertex` and `StrategyWrappedEdge` properly wrap `Element` objects returned from non-traversal based methods.
* Gremlin-Server now sends a single write with status 200 for Object and empty response messages.
* `GremlinGroovyScriptEngine` allows imports to re-import dependencies added via "use".
* Changed order in which the `GremlinExecutor` is initialized such that dependency loading via "use" are handled first which fixes problems with starting Gremlin Server with `gremlin-server-neo4j.yaml`.
* Corrected issues with the "branch factor" related traversals under `SubgraphStrategy`.  This change also altered the semantics of the `SubgraphStrategy` a bit as it became more restrictive around `Edge` inclusion (requires both vertices to be in the subgraph).
* The Gephi Plugin now visualizes traversals and has numerous configuration options.
* Added more specific features around the types of "identifiers" a graph can support.
* Added a new test graph called `MODERN` that is copy of the `CLASSIC` graph, but represents floats as doubles.  This graph will be the default graph for testing going forward.
* Fix bug in `Neo4jGraph` that was not processing multiple vertex labels properly when doing a `has()` step with `IN`.
* Changed semantics of `@LoadGraphWith` in gremlin-test to only refer to the ability of a test implementation to process the data types of the test graph (not to actually load it).
* `StartStep` is a `SideEffect` as it is a process to get data into the stream (like a keyboard) and more efficient as such.
* Greatly simplified the implementations of `Map`, `FlatMap`, `Filter`, and `SideEffect`.
* `Path` data structure changed to an ordered list of objects with each associated to a `Set<String>` of as-labels.
* All sideEffect-based steps no longer extend `FilterStep` with predicate equal true, but a more efficient `SideEffectStep`.
* `TreeStep` now has `TreeMapReduce` for executing on `GraphComputer`.
* `Neo4jTraversal.cypher()` is fluent throughout.
* Reverted back to TP2 model of `as()` referring to step names, not variable names of sideEffects.
* Updated `AddEdge`-step to support property key/value pairs for appending to newly created edges.
* Renamed `Graph.getFeatures()` to `Graph.features()` to be consistent with other API methods.
* `Vertex` and `Edge` now implement all `GraphTraversal` methods to ensure consistency throughout stack.
* `Neo4jTraversal` is auto-generated from `Neo4jTraversalStub` with technique generalizable to other vendors.
* Added test suite to ensure that all traversals are of the same type: `g.V`, `g.E`, `g.of()`, `v.identity()`, `e.identity()`, v-, e-methods.
* Giraph HDFS helpers now support `hdfs.mkdir(string)` and `local.mkdir(string)`
* Added `@OptIn` and `@OptOut` for implementers to specify on their `Graph` implementations for test compliance information.
* `GraphComputer` `Memory` now immutable after computation is complete.
* Dependency grabbing for plugins filter out slf4j logging dependencies so as to avoid multiple bindings with the standard TinkerPop distributions.
* Fixed `GiraphMemory` to be fully consistent with GraphComputer specification.
* Removed fatJar assembly from Giraph-Graph as it is no longed needed with distributed cache model.
* Reworked `GiraphRemoteAcceptor` to provide a `result` variable back to the console with `ComputerResult`.
* `VertexProgram` is no longer `Serializable` (use `loadState` and `storeState` for wire-propagation).
* Moved `GiraphGraph.getOutputGraph()` to `GiraphHelper`.
* Changed `GIRAPH_GREMLIN_HOME` to `GIRAPH_GREMLIN_LIB` to reference directory where jars are to be loaded.
* Updated README with release instructions.

TinkerPop 3.0.0.M1 (Release Date: August 12, 2014)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* First official release of TinkerPop3 and thus, no changes.