anchor.diff:  Unlike `ConcurrentHashMap`, `ChronicleMap` stores its data off-heap; often in a memory mapped file.
   It is recommended that you call `close()` when you have finished working with a `ChronicleMap`.
   
  -``` java
  +```java
   map.close()
   ```
   
  
positive.code: 
  It is strongly recommended to update off-heap memory of values directly only within a context, and update or write lock held. Within a context, you are provided with an entry object of `MapEntry` type. To re-compute entry checksum manually, cast that object to `ChecksumEntry` type and call the `.updateChecksum()` method:
  
  ``` java
  try (ChronicleMap<Integer, LongValue> map = ChronicleMap
          .of(Integer.class, LongValue.class)
          .entries(1)
  
negative.code:     names.getUsing(key, name);
      // process the name...
   }
  ```
  
  In this case, calling `names.getUsing(key, name)` is equivalent to:
  
  ```java
   name.setLength(0);
   name.append(names.get(key));
  ```
  
  The difference is that it doesn't generate garbage. The value type is the value interface. Pass the heap instance to read the data into it without new object allocation:
  
  ```java
   ThreadLocal<PostalCodeRange> cachedPostalCodeRange =
      ThreadLocal.withInitial(() -> Values.newHeapInstance(PostalCodeRange.class));
  
  