anchor.diff:  <2> The `call` method is used to invoke the function
   <3> the `{ ... }` delimiter can be replaced by `do ... end` for multiline functions
   
  -Then passing functions to methods uses a special feature.
  +Then, passing functions to methods uses a special feature.
   Methods can receive a block of code as a special argument,
   this block is then called using the `yield` keyword.
   [source,ruby]
  
positive.code: <3> Call the setter
  <4> Call the getter
  
  ### Meta programming
  
  Ruby has a powerful API similar to Java reflection:
  
negative.code: 
  ## The bad
  
  ### Strings
  
  Strings are mutable:
  [source, ruby]
  ----
  hi = "Hello "
  hi << "world"
  ----
  The above example is similar to a Java `StringBuilder`: at the end `hi` contains `Hello world`.
  I know that having immutable Strings in Java allows many optimizations in the JVM, I wonder what's the performance penalty of having mutable strings.
  
  Multiline strings is something I miss in Java, but Ruby's syntax is rather strange.
  They are delimited with `%{ ... }` or `%! ... !` or ...:
  [source, ruby]
  ----
  multiline = %{
  First line
  Second line
  }
  ----
  
  ### Unless
  
  I am not a big fan of this `unless` keyword which does the contrary of `if`
  