anchor.diff:  
   When you create a ring buffer then any reader can block all writers. If a reader stops reading
   then this will eventually block writers. The number of readers is fixed, and they are all created when the ring buffer is
  -created; when the underlying BytesStore is first written-to. The readers will live for as long as the ring buffer; until
  -you stop using the BytesStore.
  +created; when the underlying BytesStore is first written to. The readers will live for as long as the ring buffer (actually
  +as until long as the underlying BytesStore - you can re-create a new ring buffer over the same BytesStore).
   
   Backing the ring buffer with a persistent BytesStore (that is, one backed with a memory-mapped file) means it will be
   visible to multiple processes. All processes can write to, and read from, the ring buffer.
  
positive.code: == Chronicle Queue Enterprise Ring Buffer
  
  Chronicle Queue Enterprise Ring Buffer provides a high performance, multi-writer, multi-reader, ring buffer implementation
  which can be used in your application code. https://jerryshea.github.io/2018/07/27/RingBuffer.html[This article]
  gives some examples of how high-percentile latencies can be reduced.
  
  Additionally, it allows the ring buffer to be accessed
  through two different implementations of the `ChronicleQueue` interface.
  
  .Chronicle Ring Buffer
  image::images/Ring_buffer.svg[]
  
negative.code: 
  ```
      // process 1
      EnterpriseChronicleQueueBuilder builder = EnterpriseChronicleQueueBuilder.binary(path);
      try (@NotNull ChronicleQueue queue = builder.bufferCapacity(1 << 20)
              .readBufferMode(BufferMode.Asynchronous)
              .writeBufferMode(BufferMode.Asynchronous)
              // RB_BYTES_STORE_CREATOR_MAPPED_FILE is an *example* implementation of a bufferBytesStoreCreator
              // which creates a memory-mapped file located in a fast filesystem (/tmp) and has same name as
              // underlying queue, thus allowing its contents to be mapped and shared between processes.
              .bufferBytesStoreCreator(builder.RB_BYTES_STORE_CREATOR_MAPPED_FILE)
              .build()) {
          ExcerptAppender appender = queue.acquireAppender();
          ...
      }
  
      // process 2
      EnterpriseChronicleQueueBuilder builder = EnterpriseChronicleQueueBuilder.binary(path); // same path as process 1
      try (@NotNull ChronicleQueue queue = builder.bufferCapacity(1 << 20)
              .readBufferMode(BufferMode.Asynchronous)
              .writeBufferMode(BufferMode.Asynchronous)
              .bufferBytesStoreCreator(builder.RB_BYTES_STORE_CREATOR_MAPPED_FILE)
              .build()) {
          ExcerptTailer tailer = queue.createTailer();
          ...
  