anchor.diff:  in.close();
   ----
   
  -But that was before, with Vert.x you do:
  +But with Vert.x we are more likely to do:
   
   [source, java]
   -----
  
positive.code: ## Vert.x
  
  Let's first explain what is Vert.x in a few lines. As said in the previous section, Vert.x is _"a toolkit for building
  reactive applications on the JVM"_.
  
  The first important word here is **toolkit**. So, Vert.x is not an application server, a container or a framework.
  It's not a JavaScript library either. Vert.x is a `jar` file, so a Vert.x application is an application using this `jar`
   file. Vert.x does not define a packaging model, all Vert.x _components_ are plain _boring_
   `jar` files. How does this impact you and your application? Let's imagine you are using a build tool such as
   Maven or Gradle, to make your application a Vert.x application just add the `vertx-core` dependency. Wanna use another
   Vert.x components, just add it as a dependency. It's simple, burden-less. Starting the application is a simple class
   with the `public static void main(String[] args)` entry point. No specific IDE or plugin to install, and there is
   nothing to install to start using Vert.x.
  
  Then, to use the awesomeness provided by Vert.x, you just need to use it in your code, but be patient, this will be
  covered later.
  
  Another important word in the Vert.x description is **reactive**. Vert.x is made to build reactive
  applications, actually **systems**. Reactive systems footnote:[Reactive systems and reactive programming are two
  different _things_. Reactive programming is a development model observing and manipulating data streams, while
  reactive systems are systems reacting to requests, failures, picks of load and interacting using async messages.] has
  been defined in the  http://reactivemanifesto.org[Reactive Manifesto]. Even if it's not that long to read, let's
  summarized it in 4 bullet points:
  
  * Responsive: a reactive system needs to handle requests in a _reasonable_ time (I let you define _reasonable_).
  * Resilient: a reactive system must stay responsive in the face of _failures_ (crash, timeout, `500` errors...), so
  it must be _designed for failures_ and deal with them.
  * Elastic: a reactive system must stay responsive under various load. As a consequence, it must scale up and down, and
  being able to handle the load with minimal resources.
  * Message driven: components from a reactive system interacts using **asynchronous message-passing**.
  
  This last point defines the essence of Vert.x - it's event-driven and also non-blocking. Events are delivered in an
  _event loop_ that you **must never block**. Let's explain why. Unlike traditional, let's say "enterprise", systems,
  Vert.x uses a very small number of threads. Some of these threads are _event loops_, they are responsible for
  dispatching the events in `Handlers`. If you block this thread, the events won't be delivered anymore. This
  execution model impacts how you write your code, instead of _traditional_ blocking code, your code is
  going to be asynchronous footnote:[Asynchronous: the caller does not wait for a returned response, but pass
   a _callback_ executed when the result has been computed] and non-blocking footnote:[Non-blocking: the code
    must not block the executing thread - so it must avoid blocking IO, long processing time...].
  
  Before, you were doing:
  
  [source, java]
  ----
  
negative.code: 3. _request / reply_: the message is sent to a single _consumer_ and let it _reply_ to the message by sending another
  _message_ to the initial sender
  
  Wao!, that's a lot of information to process... However, you might still want to ask: **What kind of applications can I use Vert.x for?** We say, Vert.x is
  incredibly flexible - whether it's simple network utilities, sophisticated modern web applications, HTTP/REST
  microservices, high volume event processing or a full blown backend message-bus application, Vert.x is a great fit.
  It's fast, and does not constraint you. Last but not least, Vert.x provides appropriate tools to build reactive systems; sytems that are: _responsive, elastic, resilient and asynchronous_!
  
  
  