anchor.diff:  and event-driven and require a small number of threads to scale vertically (i.e. within the
   JVM) rather than horizontally (i.e. through clustering).
   
  -A key aspect of the reactive applications is the concept of backpressure which is
  +A key aspect of reactive applications is the concept of backpressure which is
   a mechanism to ensure producers don't overwhelm consumers. For example in a pipeline
  -of reactive components extending from the database to the HTTP connection when the
  -HTTP client is slow the data repository also slows down or stops until capacity frees up.
  -
  -Reactive programming also involves a major shift from imperative style logic
  -to declarative async composition of 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
  +of reactive components extending from the database to the HTTP response when the
  +HTTP connection is too slow the data repository can also slow down or stop completely
  +until network capacity frees up.
  +
  +Reactive programming also leads to a major shift from imperative to declarative async
  +composition of logic. It is comparable to writing blocking code vs using the
  +`CompletableFuture` from Java 8 to compose follow-up actions via lambda expressions.
  +
  +For a longer introduction check the blog 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: 
  
  [[web-reactive-client]]
  === Client-Side Reactive Web Support
  
  Spring Framework 5 includes a functional, reactive `WebClient` that offers a fully
  non-blocking and reactive alternative to the `RestTemplate`. It exposes network
  
negative.code: 
  
  [[web-reactive-http-body]]
  === Request and Response Body Conversion
  
  The `spring-core` module provides reactive `Encoder` and `Decoder` contracts
  that enable the serialization of a `Flux` of bytes to and from typed objects.
  