anchor.diff:  [[difference-with-aleph]]
   === What is the difference between _catacumba_ and Aleph?
   
  -First of all, Aleph is one of the most robust libraries in the Clojure ecosystem for 
  -building asynchronous servers. Here is an incomplete list of differences and motivations 
  +First of all, Aleph is one of the most robust libraries in the Clojure ecosystem for
  +building asynchronous servers. Here is an incomplete list of differences and motivations
   why I wrote _catacumba_ instead of using _aleph_ directly in my applications:
   
  -- Aleph with manifold offers good abstractions for creating async servers but they are 
  +- Aleph with manifold offers good abstractions for creating async servers but they are
     much too low level and only provide the basic building blocks. _catacumba_ intends to be
  -  a toolkit that is highly focused on web development by providing a good collection of 
  +  a toolkit that is highly focused on web development by providing a good collection of
     features that matter to web developers.
  -- I wrote _catacumba_ to have an alternative to ring and _Aleph_ that uses ring's 
  +- I wrote _catacumba_ to have an alternative to ring and _Aleph_ that uses ring's
     abstractions for handling web requests.
   - Aleph has a good path to have an easily readable  and user friendly documentation.
   - Aleph is build on manifold streams and _catacumba_ uses reactive-streams abstractions.
  
positive.code: ==== Promises
  
  Promises are another abstraction supported out of the box in _catacumba_. It comes from
  the link:https://github.com/funcool/futura[futura library] and is build on top of JDK8
  _CompletableFuture_.
  
  Sometimes, you do not need send a chunked stream to the client, but your "bussines logic"
  is defined in an asynchronous friendly API using promises (or something similar). In this
  
negative.code: If you are familiar with the ring based session storages, you can observe that the
  _catacumba_ session storage abstraction is almost identical to the ring session
  abstraction, so migrating from or adapting the ring session storages is really easy. The
  unique difference is that functions should return a promise (from promissum library).
  
  To use a concrete session storage, just pass a instance of it as value of the `:storage`
  key in a session handler constructor:
  