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: 
  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 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 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 (e.g., not the case for Android).
  ** All *RingBuffer* based features will not work when Unsafe is missing.
  * 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.
  
  [[architecture]]
  === Architecture Overview
  .The main modules present in Reactor 2.0
  image::images/modules.png[Module Organization, width=500, align="center", link="images/modules.png"]
  
  The Reactor codebase is divided into several submodules to help you pick the ones that suit your needs while not burdening you with functionality you don't need.
  
  Following are some examples of how one might mix-and-match reactive technologies and Reactor modules to achieve your asynchronous goals:
  
  * Spring XD + Reactor-Net (Core/Stream) : Use Reactor as a Sink/Source IO driver.
  * Grails | Spring + Reactor-Stream (Core) : Use Stream and Promise for background Processing.
  * Spring Data + Reactor-Bus (Core) : Emit Database Events (Save/Delete/...).
  * Spring Integration Java DSL + Reactor Stream (Core) : Microbatch MessageChannel from Spring Integration.
  * RxJavaReactiveStreams + RxJava + Reactor-Core : Combine rich composition with efficient asynchronous IO Processor
  * RxJavaReactiveStreams + RxJava + Reactor-Net (Core/Stream) : Compose input data with RxJava and gate with Async IO drivers.
  
  .A *quick* overview of how Reactor modules depend on one another
  image::images/overview.png[Architecture Overview, width=650, align="center", link="images/overview.png"]
  
  [[reactivestreams]]
  === Reactive Streams
  
  http://www.reactive-streams.org[Reactive Streams] is a new 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 aim of the standard is to provide (a)synchronous data sequences with a flow-control mechanism. The specification is fairly light and first targets the JVM.
  It comes with 4 Java Interfaces, a TCK and a handful of examples. It is quite straightforward to implement the 4 interfaces for the need,
  but the meat of the project is actually the behaviors verified by the TCK. A provider is qualified _Reactive Streams Ready_ since
  it successfully passed the TCK for the implementing classes, which fortunately we did.
  
  .The Reactive Streams Contract
  image::images/rs.png[The Reactive Streams Contract, width=500, align="center"]
  
negative.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.
  ****
  