anchor.diff:  
   === Safe against malicious input.
   
  -Chronicle Wire has built in tiers of bounds checks to prevent accidental read/writing that corrupts the data. It is not complete enough for a security review.
  -   
  +Chronicle Wire has built in tiers of bounds checks to prevent accidental read/writing that corrupts the data.
  +It is not complete enough for a security review.
  +
   === Reflection / generic algorithms.
   
  -Chronicle Wire supports generic reading and writing of an arbitrary stream. This can be used in combination with predetermined fields.
  +Chronicle Wire supports generic reading and writing of an arbitrary stream.
  +This can be used in combination with predetermined fields.
   For example, you can read the fields you know about, and ask it to provide the fields that you do not.
   You can also give generic field names like keys to a map as `YAML` does.
   
   === Initialization order.
   
   Chronicle Wire can handle unknown information like lengths, by using padding.
  -It will go back and fill in any data that it was not aware of when it was writing the data. For example, when it writes an object, it does not know how long it is going to be, so it adds padding at the start. Once the object has been written, it goes back and overwrites the length. It can also handle situations where the length was more than needed; this is known as packing.
  +It will go back and fill in any data that it was not aware of when it was writing the data.
  +For example, when it writes an object, it does not know how long it is going to be, so it adds padding at the start.
  +Once the object has been written, it goes back and overwrites the length.
  +It can also handle situations where the length was more than needed; this is known as packing.
   
   === Unknown field retention?
   
  -Chronicle Wire can read data that it did not expect, interspersed with data it did expect. Rather than specify the expected field name, a `StringBuilder` is provided.
  -
  -Note: There are times when you want to skip/copy an entire field or message, without reading any more of it.  This is also supported.
  +Chronicle Wire can read data that it did not expect, interspersed with data it did expect.
  +Rather than specify the expected field name, a `StringBuilder` is provided.
  +
  +NOTE: There are times when you want to skip/copy an entire field or message, without reading any more of it.
  +This is also supported.
   
   === Object-maximumLimit RPC system.
   
   Chronicle Wire supports references based on name, number, or UUID. This is useful when including a reference to an object that the reader should look up by other means.
  -   
  +
   A common case is if you have a proxy to a remote object, and you want to pass or return this in an RPC call.
   
   === Schema language
   
  -Chronicle Wire's schema is not externalised from the code. However it is planned to use `YAML` in a format that it can parse.
  +Chronicle Wire's schema is not externalised from the code.
  +However, it is planned to use `YAML` in a format that it can parse.
   
   === Usable as mutable state
   
  -Chronicle Wire supports storing an application's internal state. This will not allow it to grow or shrink. You can't free any of it without copying the pieces that you need, and discarding the original copy.
  -    
  +Chronicle Wire supports storing an application's internal state.
  +This will not allow it to grow or shrink.
  +You can't free any of it without copying the pieces that you need, and discarding the original copy.
  +
   === Padding takes space on the wire.
   
  -The Chronicle Wire format that is chosen determines if there is any padding on the wire. If you copy the in-memory data directly, its format does not change.
  -
  -If you want to drop padding, you can copy the message to a wire format without padding. You can decide whether the original padding is to be preserved or not, if turned back into a format with padding.
  +The Chronicle Wire format that is chosen determines if there is any padding on the wire.
  +If you copy the in-memory data directly, its format does not change.
  +
  +If you want to drop padding, you can copy the message to a wire format without padding.
  +You can decide whether the original padding is to be preserved or not, if turned back into a format with padding.
   
   We could look at supporting *Cap'n'Proto*'s zero-byte removal compression.
   
   === Un-set fields take space on the wire?
   
  -Chronicle Wire supports fields with, and without, optional fields, and automatic means of removing them. Chronicle Wire does not support automatically adding them back in, because information has been lost.
  +Chronicle Wire supports fields with, and without, optional fields, and automatic means of removing them.
  +Chronicle Wire does not support automatically adding them back in, because information has been lost.
   
   === Pointers take space on the wire.
   
  
positive.code: 
  === Simple Binary Encoding (SBE)
  
  Simple Binary Encoding (SBE) is designed to be a more efficient replacement for FIX. It is not limited to FIX protocols, and can be easily extended by updating an XML schema. It is simple, binary, and it supports C++ and Java.
  
  XML, when it first started, did not use XML for its own schema files, and it is not insignificant that SBE does not use SBE for its schema either.  This is because it is not trying to be human readable. It has XML which, though standard, is not designed to be human readable either.  Chronicle believes that it is a limitation that it does not naturally lend itself to a human readable form.
     
  The encoding that SBE uses is similar to binary; with field numbers and fixed-width types.
  
  SBE assumes the field types, which can be more compact than Chronicle Wire's most similar option; though not as compact as others.
     
  SBE has support for schema changes provided that the type of a field doesn't change.
     
  === Message Pack (`msgpack`)
  
  Message Pack is a packed binary wire format which also supports `JSON` for human readability and compatibility. It has many similarities to the binary (and `JSON`) formats of this library.  Chronicle Wire is designed to be human readable first, based on `YAML`, and has a range of options to make it more efficient. The most extreme being fixed position binary.
      
  Message Pack has support for embedded binary, whereas Chronicle Wire has support for comments and hints, to improve rendering for human consumption.
      
  The documentation looks well thought out, and it is worth emulating.
  
  === Comparison with Cap'n'Proto
  
negative.code: Using `RawWire` strips away all the meta data to reduce the size of the message, and improve speed.
  The down-side is that we cannot easily see what the message contains.
  
  [source,Java]
  ----
          // the same code as for text wire
          wire3.write(() -> "message").text("Hello World")
  