Re: [dispatch] draft-devault-bare-07 to be discussed during IETF 114

[Jiri Vlasak <[e-mail]>]

I am sorry for letting you wait.

> The world is well-supplied with schema-driven binary encoding schemes,
> all claiming excellent compatibility and performance characteristics:
> Avro, Protobufs, Cap'n proto, Thrift, FlatBuffers are the ones I can
> think of off the top of my head.

I found the comparison on wiki [1]. What is unfortunate, in my opinion,
is that neither of the above protocols/frameworks/libraries is, to my
knowledge, standardized. (Now we can discuss about "de facto standard"
and if the standardization matters.)

> I'd be interested in hearing why BARE is different/better/interesting.

BARE has concise messages; it does not embed the schema. The messages
are octet-aligned and use little-endian representation. The encoding is
bijective when possible [2]. BARE is designed with the simplicity of
implementation in mind.

BARE specifies many primitive types:

- variable-length unsigned/signed integers: uint, int
- unsigned integers of different lengths: u8, u16, u32, u64
- signed integers of different lengths: i8, i16, i32, i64
- floating-point numbers: f32, f64
- bool, (utf-8) string, variable- and fixed-length (arbitrary) data,
  void, enum

which is not the case for the other specifications, e.g. only Cap'n
proto and FlatBuffers (from the above) specify all the fixed-length
integers (u8, u16, u32, u64, i8, i16, i32, i64), but they both miss the
variable-length integers.

Only FlatBuffers seems to specify fixed-length list/data, but maybe I am
just missing something.

BARE specifies aggregate types that store zero or more value(s) of
primitive or aggregate types:

- optional -- a value of "type" that may or may not be present
- variable- and fixed-length list of "type" values
- a mapping of "type B" values keyed by "type A" values
- a tagged union containing single value of any "type" from a set of
  "types" agreed upon in advance
- a struct -- a set of values of arbitrary "types" concatenated in an
  order agreed upon in advance

The distinction between primitive and aggregate types is clear --
primitive type encodes just one value; aggregate type encodes zero or
more values. Complex types are to be created by users by composing
primitive and aggregate types.

Even comprehensive, BARE is kept simple and well-defined.

[1]: https://en.wikipedia.org/wiki/Comparison_of_data-serialization_formats
[2]: https://github.com/bare-ts/tools#why-bare