anchor.diff:  
   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
  +```java
   try (ChronicleMap<Integer, LongValue> map = ChronicleMap
           .of(Integer.class, LongValue.class)
           .entries(1)
  
positive.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));
  
  
negative.code: 
  It is accessible within a single JVM process; the process in which it was created. The data is accessible while the process is alive. When the process is terminated, the data is cleared.
  
  ```java
  import net.openhft.chronicle.map.*
  .....
  
  