anchor.diff:  ----
   ****
   
  -You may wonder how you will be able to call blocking code. Don't worry, Vert.x provides several way to do so. A
  -constructs named `executeBlocking` and a type of verticle (named _worker_) not executed on the event loop.
  +You may wonder how you will be able to call blocking code. Don't worry, Vert.x provides several ways to do so. A
  +construct named `executeBlocking` and a type of verticle named _worker_ are not executed on the event loop.
   
   ### Exercise 4 - Sending and receiving messages
   
  -Verticles are a great way to structure your code. But how do verticles interact? They use the event bus. Verticles
  -can send and receive messages. Let's see how it works. The exercice 4 is composed by 2 verticles: a sender and a
  -receiver. The sender emits a greeting message periodically. The receiver print this message in the console. As JSON
  -is a very common format in vert.x applications, this exercise also introduces the `JsonObject`, a structure to create
  +Verticles are a great way to structure your code, but how do verticles interact? They use the event bus to 
  +send and receive messages. Let's see how it works. Exercise 4 is composed of 2 verticles: a sender and a
  +receiver. The sender emits a greeting message periodically. The receiver prints this message to the console. As JSON
  +is a very common format in Vert.x applications, this exercise also introduces the `JsonObject`, a facility to create
    and manipulate JSON structures.
   
  -First, open the `io.vertx.workshop.exercise.Exercise4SenderVerticle` class and follow the instructions to send a
  +First, open the `vertx-exercises/src/main/java/io/vertx/workshop/exercise/Exercise4SenderVerticle.java` file and follow the instructions to send a
   greeting message every 2 seconds. This message is a JSON structure: `{"message":"hello"}`. Do not hesitate to extend
   it if you want.
   
  
positive.code: programming_ principles for Java. With this development model, we manipulate _streams_ (called `Flowable`,
  `Observable`, `Maybe`, `Single` or `Completable` depending on the number of items and their characteristics). RX Java
   provides a lots of operators to compose _streams_ together and so write asynchronous orchestration easily. This
   exercise is a very basic introduction to RX Java. We will cover more deeply the different constructs later in the
   workshop.
  
  Open the `io.vertx.workshop.exercise.Exercise6HttpVerticle` and follow the instruction. Notice the `import`
  statements containing the `reactivex` package. This package contains the _RX-ified_ vert.x API.
  
  [.assignment]
  ****
  
negative.code: In the `Exercise2Verticle` class, call sleep before writing the result into the response.
  
  When running this code and calling the server, you can see that the requests are not served in a timely fashion
  anymore. With the thread being blocked, it can't serve the subsequent requests before completing the first one.
  
  Also notice the output in the console, Vert.x detects that the event loop has been blocked and starts yelling ...
  
  [.assignment]
  ****
  