anchor.diff:  
   Furthermore, the threads must be able to send moves to each other,
   even if it's only to share the winning move.
  -This too, posed a challenge. _OptaPlanner is an Object Orientated constraint solver_,
  -so it's decision variables can be any valid Java type (not just booleans, numbers and floats), such as `Employee` or `Foo`.
  +This too, posed a challenge. _OptaPlanner is an Object Oriented constraint solver_,
  +so its decision variables can be any valid Java type (not just booleans, numbers and floats), such as `Employee` or `Foo`.
   Those variables can sit in any domain class (called planning entities), such as `Shift` or `Bar`.
   The move instances reference those class instances. When a solution gets cloned to initiate a move thread,
   those planning entities, such as `Shift` get cloned too.
  -So when a move from thread A gets send to thread B, OptaPlanner rebases the move on the solution state of thread B.
  +So when a move from thread A gets sent to thread B, OptaPlanner rebases the move on the solution state of thread B.
   This replaces the references from the move instance to thread A's solution state
   with the equivalent references of thread B's solution state. Pretty nifty.
   
  
positive.code: 
  Ah, this brings us to incremental score calculation. The key to performance.
  It is the rocket science at the heart of OptaPlanner that brings massive scalability.
  And - for the few that have seen them - the cause of the notorious score corruption exception.
  
  What is incremental score calculation?
  For each move, we calculate the score of the solution state after applying that move.
  
negative.code: is theoretically around 500 times faster than a non-incremental score calculator.
  *To offset the loss of an incremental solver on a dataset of a 1000 planning entities,
  a multithreaded non-incremental solver would need around 500 CPU cores (in theory).*
  In practice, the numbers vary, but the gain of incremental solving always outweighs the gain of multithreaded solving.
  
  Of course, now, we can have our cake and eat it too.
  
  