anchor.diff:  In this example the second handler prints the message found in the context.
   
   
  -== Asynchronous & Non blocking
  -
  -=== Asynchronous type handlers
  -
  -Async handlers in _catacumba_ are handlers that returns core.async channels in body or as response
  -value.
  -
  -Returning channel as a body has the advantage that you have the ability of set additional
  -headers and returning code. But, if you are return a channel as a response value, the default
  -status code will be set for you. The behavior of two approaches is the same, resultin in a chunked
  -encoded response to the client.
  +== Asynchronous Handlers
  +
  +_Catacumba_ has support for multiple abstractions for asynchronous (stream or not) abstractions and
  +addopts a flexible and extensible way for make easy for the user adapt it to hes needs and hes
  +abstractions.
  +
  +The main abstraction are defined in the link:http://ffff.com[futura library], that provides basic
  +building blocks for promise like abstractions and stream abstraction.
  +
  +The link:http://ffff.com[futura library] instead of reinvent the wheel, is build up on existing
  +implementations such as:
  +
  +* _JDK8 CompletableFuture_ for *promise* abstraction.
  +* _Reactive Streams_ for the *stream* abstraction.
  +
  +Using the link:http://www.reactive-streams.org/[reactive streams] instead of reinvent yet another
  +stream abstraction has huge amount of advantages. There three most important:
  +
  +* Interoprability with all libraries that has support for reactive streams
  +* Well and strongly defined behavior of the abstraction.
  +* Comes with support for *backpressure* in its core (that is mandatory in asynchronous environments).
  +
  +
  +=== Channels
  +
  +The `core.async` channels is one of the supported abstractions that is supported by _catacumba_ out
  +of the box. It consists in a handler that returns a body as a channel or response as a channel.
   
   This is the aspect of async handler returning the channel as a body:
   
  
positive.code:     (http/ok ch)))
  ----
  
  And this is the aspect of async handler returning channel as response:
  
  [source, clojure]
  
negative.code: 
  === Requirements
  
  _Catacumba_ is only runs with *JDK8* and *Clojure 1.7+* (due to extensive use of transducers
  and jdk8 concurrency primitives).
  
  
  === Leiningen
  