byte

Lets say each byte is encoded in 10 bits on the disk.

Three trillion bytes is 30 trillion bits in that case, or 3x10E13 bits.

Consider for instance chopping one byte off the start of a ucs2-encoded string - you'll get complete garbage.

Endian-agnostic due to being specified as a byte stream4.

The problem is that strstr returns a pointer, and converting a pointer to a smaller integer type throws away the high bytes.

Aside from the fact that you're wasting an entire byte of your representation, this means that you can't check for equality by comparing bits.

This works by finding little pieces in your code that do something simple like increment a register or write a byte of data, followed by a "return" instruction.

Folks should get together and build a really good processor of bytes coming over the wire that's delivered in a particular format to be rendered on the screen.

Instead, the verifier should have simply created their own properly-padded message block from the original content and verified the whole block byte-for-byte.

Contains no null bytes, so it can fit in any normal C stringPoint 1 is absolutely vital for backwards-compatibility and 2 makes it better than a lot of other multibyte encodings.

You can always tell if you're reading a part of a multibyte character or not, meaning that you can tell if you're reading a message that was cut in some random point and can tell how many bytes to drop before reaching the first start of a character3.

Say, if your game's entities take up a maximum of 32 bytes of memory each, and you are ok with imposing a hard limit of 256 entities in the world at once, you could allocate an 8 kilobyte memory buffer and manage it yourself.

Plenty of environments have safe/efficient zero-copy chained byte buffer implementations/libraries.> loads of internal consistency checksLibrary correctness isn't a unique feature.> patterns like pub/sub and request/reply, batchingAh-ha!