anchor.diff:  [[start]]
   === What is Reactor ?
   
  -So you came to have a look at Reactor. Maybe you typed some keywords into your favorite search engine like _Reactive_,
  -_Spring+Reactive_, _Asynchronous+Java_ or just _What the heck is Reactor?_. In a nutshell Reactor is a lightweight, foundational library for the JVM that helps your service or application to _efficiently_ and _asynchronously_ pass messages.
  +In a nutshell Reactor is a lightweight, foundational library for the JVM that helps your service or application to _efficiently_ and _asynchronously_ pass messages.
   
   .What do you mean by "efficiently"?
   ****
  
positive.code: ** Then after onNext has been deemed successful (e.g. after Commit, Flush etc...), request more data
  ** It is encouraged to use a linear number of requests. Try avoiding overlapping requests, e.g. requesting 10 more data every next signal.
  ****
  
  .What are the artifacts that Reactor directly use so far:
  [cols="4*", options="header"]
  |===
  
  |Reactive Streams
  |Reactor Module(s)
  |Implementation(s)
  |Description
  
  |Processor
  |reactor-core, reactor-stream
  |reactor.core.publisher.\*, reactor.rx.*
  |In Core, we offer backpressure-ready RingBuffer*Processor and more, in Stream we have a full set of Operations and Broadcasters.
  
  |Publisher
  |reactor-core, reactor-bus, reactor-stream, reactor-net
  |reactor.core.publisher.\*, reactor.rx.*, reactor.rx.action.\*, reactor.io.net.*
  |In Core, processors implement Publisher. In Bus we publish an unbounded emission of routed events. In Stream, our Stream extensions directly implement Publisher. In Net, Channels implement Publisher to consume incoming data, we also provide publishers for flush and close callbacks.
  
  |Subscriber
  |reactor-core, reactor-bus, reactor-stream, reactor-net
  |reactor.core.publisher.\*, reactor.bus.EventBus.*, reactor.rx.action.\*, reactor.io.net.impl.*
  |In Core, our processor implement Subscriber. In Bus, we expose bus capacities with unbounded Publisher/Subscriber. In Stream, actions are Subscribers computing specific callbacks. In Net, our IO layer implements subscribers to handle writes, closes and flushes.
  
  |Subscription
  |reactor-stream, reactor-net
  |reactor.rx.subscription.\*, reactor.io.net.impl.*
  |In Stream, we offer optimized PushSubscriptions and buffering-ready ReactiveSubscription. In Net, our Async IO reader-side use custom Subscriptions to implement backpressure.
  
  
  |===
  
  We have worked with the standard since the inception of Reactor 2 and progressed in our journey until the *1.0.0* was about to release.
  It is now available on _Maven Central_ and other popular mirrors. You will also find it as a *transitive dependency to reactor-core*.
  
  [[rx]]
  === Reactive Extensions
  
  Reactive Extensions, or more commonly https://msdn.microsoft.com/en-gb/data/gg577609.aspx[Rx],
  are a set of well-defined Functional APIs extending the Observer pattern to an epic scale.
  
  .Rx patterns support implementing Reactive data sequences handling with a few design keys:
  * Abstract the time/latency away with a callback chain: only called when data is available
  * Abstract the threading model away: Synchronous or Asynchronous it is just an _Observable_ / _Stream_ we deal with
  * Control error-passing and terminations: error and complete signals in addition to the data payload signal are passed to the chain
  * Solve multiple scatter-aggregation and other composition issues in various predefined API.
  
  The standard implementation of Reactive Extensions in the JVM is https://github.com/ReactiveX/RxJava[RxJava].
  It provides a powerful functional API and ports mostly all the concept over from the original Microsoft library.
  
  Reactor 2 provides a <<streams.adoc#streams,specific module>> implementing a subset of the documented Reactive Extensions and on a very few occasion adapting the name
  to match our specific behavior. This focused approach around data-centric issues (microbatching, composition...) is depending on
  Reactor <<core.adoc#core-functional,Functional>> units, <<core.adoc#core-dispatchers,Dispatchers>> and the <<gettingstarted.adoc#reactivestreams, Reactive Streams>> contract.
  We encourage users who need the full flavor of Reactive Extensions to try out RxJava and https://github.com/ReactiveX/RxJavaReactiveStreams[bridge with us].
  In the end the user can benefit from powerful asynchronous and IO capacities provided by Reactor while composing with the complete RxJava ecosystem.
  
  NOTE: Some operations, behaviors, and the immediate understanding of Reactive Streams are still unique to Reactor as of now and we will try to flesh out
  the unique features in the <<streams.adoc#streams,appropriate section>>.
  
  IMPORTANT: <<net.adoc#net-overview,Async IO>> capabilities are also depending on _Stream Capacity_ for
  backpressure and auto-flush options.
  
  .Misalignments between Rx and Reactor Streams
  [cols="3*", options="header"]
  |===
  
  |rx
  |reactor-stream
  |Comment
  
  |Observable
  |reactor.rx.Stream
  |Reflect the implementation of the Reactive Stream Publisher
  
  |Operator
  |reactor.rx.action.Action
  |Reflect the implementation of the Reactive Stream Processor
  
  |Observable with 1 data at most
  |reactor.rx.Promise
  |Type a unique result, reflect the implementation of the Reactive Stream Processor and provides for optional asynchronous dispatching.
  
  |Factory API (just, from, merge....)
  |reactor.rx.Streams
  |Aligned with a core data-focused subset, return Stream
  
  |Functional API (map, filter, take....)
  |reactor.rx.Stream
  |Aligned with a core data-focused subset, return Stream
  
  |Schedulers
  |reactor.core.Dispatcher, org.reactivestreams.Processor
  |Reactor Streams compute operations with unbounded shared Dispatchers or bounded Processors
  
  |Observable.observeOn()
  |Stream.dispatchOn()
  |Just an adapted naming for the dispatcher argument
  
  |===
negative.code: 
  Parallel to that work we also decided to re-align some of our Event-Driven and Task Coordination API to the increasingly popular and documented <<gettingstarted.adoc/#rx,Reactive Extensions>>.
  
  Reactor Core is sponsored by http://pivotal.io[Pivotal] where the two core committers are employed. Since Pivotal is
  also the home of the Spring Framework and many of our colleagues are core committers to the various Spring efforts, we both provide integration support from Reactor to Spring as well as support some important functionality of the Spring Framework like the STOMP broker relay in _spring-messaging_. That said, we don't force anyone to adopt Spring just to use Reactor. We remain an embeddable toolkit "for the Reactive masses". In fact one of the goals of Reactor is to stay un-opinionated in the ways you solve asynchronous and functional problems.
  
  Reactor Core is http://www.apache.org/licenses/LICENSE-2.0.html[Apache 2.0 licensed] and available on https://github.com/reactor/reactor[GitHub].
  
  === Requirements
  
  * Reactor needs at minimum Java 7 to execute.
  ** But the full expressive potential of functional composition happens with Java 8 Lambdas.
  ** As a fallback have a look at Spring, Clojure or Groovy extensions.
  * Reactor runs at full capacity when the JVM supports *Unsafe* access
  * Reactor is packaged as traditional JAR archives in Maven Central and can be pulled into any JVM project as a dependency using your preferred build tool.
  
  [[reactivestreams]]
  === Reactive Streams
  
  http://www.reactive-streams.org[Reactive Streams] is a reactive standard, adopted by different vendors and tech
  industrials including Netflix, Oracle, Pivotal or Typesafe with a target to include the specification into Java 9 and onwards.
  
  .The Reactive Streams Contract
  image::images/rs.png[The Reactive Streams Contract, width=500, align="center"]
  