anchor.diff:  *Buffy* is a excelent library, and I have used it in some circumstances, but is has
   some things that I personally don't like:
   
  -- It works only with netty bytebuf and I need an abstraction for work with 
  +- It works only with netty bytebuf and I need an abstraction for work with
     different implementations, including in clojurescript.
  -- It has slightly strange and not uniform api when dynamic frames (arbitrary 
  +- It has slightly strange and not uniform api when dynamic frames (arbitrary
     length size types) are used. _octet_ offers unified api for both type of specs.
  -- It wraps bytebuf in a self defined type. _octet_ is a lightweight abstraction 
  +- It wraps bytebuf in a self defined type. _octet_ is a lightweight abstraction
     that works over host implementations, without wrapping them.
   - It not has support for ClojureScript
   
   
   *What is the difference with _ztellman/gloss_?*
   
  -Gloss is also similiar project, and has similar purposes, but it has several 
  +Gloss is also similiar project, and has similar purposes, but it has several
   differeces:
   
  -- It has a limited set of types. Octet has an extensible abstraction for build own 
  +- It has a limited set of types. Octet has an extensible abstraction for build own
     arbitrary type specs.
  -- It only works with nio as buffer implementations. Octet exposes an extensible 
  +- It only works with nio as buffer implementations. Octet exposes an extensible
     abstraction and support few differents out of the box.
   - In my opinion it has slightly ugly and unclear api.
   - Seems not very maintained (has issues from 2013).
  
positive.code: implements the same abstraction and can be used in read or write operations.
  
  
  === Coming features
  
  - *memoryviews*: abstraction for random read/write access to buffer without parsing
    all spec related data.
  - nodejs/iojs buffer support.
  - more function for create compositions like repeated type, or key value pairs.
  
  
  == FAQ
  
negative.code: === Vectors
  
  This is a very similar abstraction to the previously explained repeating pattern.
  The main difference with it is that this one represents an arbitrary size repetition
  of one spec and allows store an array like datastructures.
  
  .Example storing two arrays in a buffer
  