anchor.diff:  
   In plain terms reactive programming is about non-blocking applications that are asynchronous
   and event-driven and require a small number of threads to scale. A key aspect of that
  -definition is the concept of backpressure which is a mechanism to ensures producers
  +definition is the concept of backpressure which is a mechanism to ensure producers
   don't overwhelm consumers. For example in a pipeline of reactive components that extends
  -from the database to the HTTP server when an HTTP connection slows down the data
  -repository slows down as well or stops until capacity frees up.
  -
  -Reactive programming involves a shift from imperative to declarative, async composition
  -of logic. This is comparable to how `CompletableFuture` in Java 8 allows declaring
  -follow-up actions in lambda expressions to be executed when the future completes.
  -
  -A proper introduction to Reactive programming is beyond scope of this documentation.
  -For a more extended introduction check the excellent multi-part series
  +from the database to the HTTP socket when the HTTP client is slow the data
  +repository slows down or stops until capacity frees up.
  +
  +From a programming model perspective reactive programming involves a major shift from imperative style logic
  +to a declarative composition of async logic. It is comparable to using `CompletableFuture` in Java 8
  +and composing follow-up actions via lambda expressions.
  +
  +For a more extended introduction to reactive programming check the excellent multi-part series
   https://spring.io/blog/2016/06/07/notes-on-reactive-programming-part-i-the-reactive-landscape["Notes on Reactive Programming"]
   by Dave Syer.
   
  
positive.code: server.start();
  ----
  
  The `WebReactiveConfiguration` at (1) is the Web Reactive Java config from the `spring-web-reactive`
  and is similar in purpose to the MVC Java config from `spring-webmvc`. It provides the
  the web framework configuration required to get started leaving you only to
  declare your own `@Controller' beans.
  
  The `DispatcherHandler` at (2) is the equivalent of the `DispatcherServlet` in Spring MVC.
  
  The `HttpServer` at (3) is an abstraction from the
  https://github.com/spring-projects/spring-framework/tree/master/spring-web/src/test/java/org/springframework/http/server/reactive/bootstrap[test sources]
  of the `spring-web-reactive` module that's used for the framework's own integration tests.
  It comes with basic implementations of all supported runtimes.
  
  
  [[web-reactive-getting-started-M1]]
  === Extent of M1 Support
  
  For M1 the Spring Web Reactive module focuses on support for REST scenarios both
  client and server-side. Basic HTML rendering with Freemarker is also supported but
  limited to rendering, i.e. there is no support form submissions yet.
  
  On the client side for M1 the Reactor Netty HTTP client is supported.
  
negative.code: [[web-reactive-getting-started-boot]]
  === Spring Boot Starter
  
  The experimental Spring Boot Web Reactive starter available via http://start.spring.io
  is the quickest way to get started. It does all the work so you can start
  writing `@Controller` classes. By default it runs on Tomcat but the dependencies can
  be changed as usual with Spring Boot to switch to a different runtime.
  
  
  [[web-reactive-getting-started-manual]]
  