Comparison of data-serialization formats
This is a comparison of data-serialization formats, various ways to convert complex objects to sequences of bits. It does not include markup languages used exclusively as document file formats.
Overview
Name | Creator-maintainer | Based on | Standardized? | Specification | Binary? | Human-readable? | Supports references?e | Schema-IDL? | Standard APIs | Supports Zero-copy operations |
---|---|---|---|---|---|---|---|---|---|---|
Apache Avro | Apache Software Foundation | N/A | No | Apache Avro™ Specification | Yes | Partialj | N/A | Yes (built-in) | C, C#, C++, Java, PHP, Python, Ruby | N/A |
Apache Parquet | Apache Software Foundation | N/A | No | Apache Parquet | Yes | No | No | N/A | Java, Python, C++ | No |
ASN.1 | ISO, IEC, ITU-T | N/A | Yes | ISO/IEC 8824; X.680 series of ITU-T Recommendations | Yes (BER, DER, PER, OER, or custom via ECN) |
Yes (XER, JER, GSER, or custom via ECN) |
Partialf | Yes (built-in) | N/A | Yes (OER) |
Bencode | Bram Cohen (creator) BitTorrent, Inc. (maintainer) |
N/A | De facto standard via BitTorrent Enhancement Proposal (BEP) | Part of BitTorrent protocol specification | Partially (numbers and delimiters are ASCII) |
No | No | No | No | No |
Binn | Bernardo Ramos | N/A | No | Binn Specification | Yes | No | No | No | No | Yes |
BSON | MongoDB | JSON | No | BSON Specification | Yes | No | No | No | No | No |
CBOR | Carsten Bormann, P. Hoffman | JSON (loosely) | Yes | RFC 7049 | Yes | No | Yes through tagging |
Yes (CDDL) |
No | No |
Comma-separated values (CSV) | RFC author: Yakov Shafranovich |
N/A | Partial (myriad informal variants used) |
RFC 4180 (among others) |
No | Yes | No | No | No | No |
Common Data Representation (CDR) | Object Management Group | N/A | Yes | General Inter-ORB Protocol | Yes | No | Yes | Yes | ADA, C, C++, Java, Cobol, Lisp, Python, Ruby, Smalltalk | N/A |
D-Bus Message Protocol | freedesktop.org | N/A | Yes | D-Bus Specification | Yes | No | No | Partial (Signature strings) |
Yes (see D-Bus) |
N/A |
Extensible Data Notation (EDN) | Cognitect | JSON (loosely) | Yes | EDN Specification | No | Yes | No | No | No | N/A |
Efficient XML Interchange (EXI) | W3C | XML, Efficient XML | Yes | Efficient XML Interchange (EXI) Format 1.0 | Yes | Yes (XML) |
Yes (XPointer, XPath) |
Yes (XML Schema) |
Yes (DOM, SAX, StAX, XQuery, XPath) |
N/A |
FlatBuffers | N/A | No | flatbuffers github page Specification | Yes | Yes (Apache Arrow) |
Partial (internal to the buffer) |
Yes | C++, Java, C#, Go, Python, Rust, JavaScript, PHP, C, Dart, Lua, TypeScript | Yes | |
Fast Infoset | ISO, IEC, ITU-T | XML | Yes | ITU-T X.891 and ISO/IEC 24824-1:2007 | Yes | No | Yes (XPointer, XPath) |
Yes (XML schema) |
Yes (DOM, SAX, XQuery, XPath) |
N/A |
FHIR | Health Level 7 | REST basics | Yes | Fast Healthcare Interoperability Resources | Yes | Yes | Yes | Yes | Hapi for FHIR[1] JSON, XML, Turtle | No |
Ion | Amazon | JSON | No | The Amazon Ion Specification | Yes | Yes | No | Yes (Ion Schema) |
No | N/A |
Java serialization | Oracle Corporation | N/A | Yes | Java Object Serialization | Yes | No | Yes | No | Yes | N/A |
JSON | Douglas Crockford | JavaScript syntax | Yes | STD 90/RFC 8259 (ancillary: RFC 6901, RFC 6902), ECMA-404, ISO/IEC 21778:2017 |
No, but see BSON, Smile, UBJSON | Yes | Yes (JSON Pointer (RFC 6901); alternately: JSONPath, JPath, JSPON, json:select()), JSON-LD |
Partial (JSON Schema Proposal, ASN.1 with JER, Kwalify, Rx, Itemscript Schema), JSON-LD |
Partial (Clarinet, JSONQuery, JSONPath), JSON-LD |
No |
MessagePack | Sadayuki Furuhashi | JSON (loosely) | No | MessagePack format specification | Yes | No | No | No | No | Yes |
Netstrings | Dan Bernstein | N/A | No | netstrings.txt | Partially (delimiters are ASCII) |
Yes | No | No | No | Yes |
OGDL | Rolf Veen | ? | No | Specification | Yes (Binary Specification) |
Yes | Yes (Path Specification) |
Yes (Schema WD) |
N/A | |
OPC-UA Binary | OPC Foundation | N/A | No | opcfoundation.org | Yes | No | Yes | No | No | N/A |
OpenDDL | Eric Lengyel | C, PHP | No | OpenDDL.org | No | Yes | Yes | No | Yes (OpenDDL Library) |
N/A |
PHP serialization format | PHP Group | N/A | Yes | No | Yes | Yes | Yes | No | Yes | N/A |
Pickle (Python) | Guido van Rossum | Python | De facto standard via Python Enhancement Proposals (PEPs) | PEP 3154 -- Pickle protocol version 4 | Yes | No | No | No | Yes () |
No |
Property list | NeXT (creator) Apple (maintainer) |
? | Partial | Public DTD for XML format | Yesa | Yesb | No | ? | Cocoa, CoreFoundation, OpenStep, GnuStep | No |
Protocol Buffers (protobuf) | N/A | No | Developer Guide: Encoding | Yes | Partiald | No | Yes (built-in) | C++, Java, C#, Python, Go, Ruby, Objective-C, C, Dart, Perl, PHP, R, Rust, Scala, Swift, Julia, Erlang, D, Haskell, Action Script, Delphi, Elixir, Elm, Erlang, GopherJS, Haskell, Haxe, JavaScript, Kotlin, Lua, Matlab, Mercurt, OCaml, Prolog, Solidity, Typescript, Vala, Visual Basic | No | |
Ethereum Recursive Length Prefix (RLP) | Ethereum | N/A | No | Specification | Yes | No | No | No | Erlang, Go, Java, Javascript, Kotlin, Objective-C, Python, Swift, PHP | Yes |
S-expressions | John McCarthy (original) Ron Rivest (internet draft) |
Lisp, Netstrings | Partial (largely de facto) |
"S-Expressions" Internet Draft | Yes ("Canonical representation") |
Yes ("Advanced transport representation") |
No | No | N/A | |
Smile | Tatu Saloranta | JSON | No | Smile Format Specification | Yes | No | No | Partial (JSON Schema Proposal, other JSON schemas/IDLs) |
Partial (via JSON APIs implemented with Smile backend, on Jackson, Python) |
N/A |
SOAP | W3C | XML | Yes | W3C Recommendations: SOAP/1.1 SOAP/1.2 |
Partial (Efficient XML Interchange, Binary XML, Fast Infoset, MTOM, XSD base64 data) |
Yes | Yes (built-in id/ref, XPointer, XPath) |
Yes (WSDL, XML schema) |
Yes (DOM, SAX, XQuery, XPath) |
N/A |
Structured Data eXchange Formats | Max Wildgrube | N/A | Yes | RFC 3072 | Yes | No | No | No | N/A | |
Apache Thrift | Facebook (creator) Apache (maintainer) |
N/A | No | Original whitepaper | Yes | Partialc | No | Yes (built-in) | C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, OCaml, Delphi and other languages[2] | N/A |
UBJSON | The Buzz Media, LLC | JSON, BSON | No | Yes | No | No | No | No | N/A | |
eXternal Data Representation (XDR) | Sun Microsystems (creator) IETF (maintainer) |
N/A | Yes | STD 67/RFC 4506 | Yes | No | Yes | Yes | Yes | N/A |
XML | W3C | SGML | Yes | W3C Recommendations: 1.0 (Fifth Edition) 1.1 (Second Edition) |
Partial (Efficient XML Interchange, Binary XML, Fast Infoset, XSD base64 data) |
Yes | Yes (XPointer, XPath) |
Yes (XML schema, RELAX NG) |
Yes (DOM, SAX, XQuery, XPath) |
N/A |
XML-RPC | Dave Winer[3] | XML | No | XML-RPC Specification | No | Yes | No | No | No | No |
YAML | Clark Evans, Ingy döt Net, and Oren Ben-Kiki |
C, Java, Perl, Python, Ruby, Email, HTML, MIME, URI, XML, SAX, SOAP, JSON[4] | No | Version 1.2 | No | Yes | Yes | Partial (Kwalify, Rx, built-in language type-defs) |
No | No |
Name | Creator-maintainer | Based on | Standardized? | Specification | Binary? | Human-readable? | Supports references?e | Schema-IDL? | Standard APIs | Supports Zero-copy operations |
- a. ^ The current default format is binary.
- b. ^ The "classic" format is plain text, and an XML format is also supported.
- c. ^ Theoretically possible due to abstraction, but no implementation is included.
- d. ^ The primary format is binary, but a text format is available.[5]
- e. ^ Means that generic tools/libraries know how to encode, decode, and dereference a reference to another piece of data in the same document. A tool may require the IDL file, but no more. Excludes custom, non-standardized referencing techniques.
- f. ^ ASN.1 does offer OIDs, a standard format for globally unique identifiers, as well as a standard notation ("absolute reference") for referencing a component of a value. Thus it would be possible to reference a component of an encoded value present in a document by combining an OID (assigned to the document) and an "absolute reference" to the component of the value. However, there is no standard way to indicate that a field contains such an absolute reference. Therefore, a generic ASN.1 tool/library cannot automatically encode/decode/resolve references within a document without help from custom-written program code.
- g. ^ VelocyPack offers a value type to store pointers to other VPack items. It is allowed if the VPack data resides in memory, but not if stored on disk or sent over a network.
- h. ^ The primary format is binary, but a text format is available.[6][7]
- i. ^ The primary format is binary, but text and json formats are available.[8]
- j. ^ The primary format is binary, a json encoder is available.[9]
Syntax comparison of human-readable formats
Format | Null | Boolean true | Boolean false | Integer | Floating-point | String | Array | Associative array/Object |
---|---|---|---|---|---|---|---|---|
ASN.1 (XML Encoding Rules) |
<foo /> |
<foo>true</foo> |
<foo>false</foo> |
<foo>685230</foo> |
<foo>6.8523015e+5</foo> |
<foo>A to Z</foo> |
<SeqOfUnrelatedDatatypes>
<isMarried>true</isMarried>
<hobby />
<velocity>-42.1e7</velocity>
<bookname>A to Z</bookname>
<bookname>We said, "no".</bookname>
</SeqOfUnrelatedDatatypes>
|
An object (the key is a field name):
<person>
<isMarried>true</isMarried>
<hobby />
<height>1.85</height>
<name>Bob Peterson</name>
</person>
A data mapping (the key is a data value): <competition>
<measurement>
<name>John</name>
<height>3.14</height>
</measurement>
<measurement>
<name>Jane</name>
<height>2.718</height>
</measurement>
</competition>
|
CSVb | null a(or an empty element in the row)a |
1 atrue a |
0 afalse a |
685230 -685230 a |
6.8523015e+5 a |
A to Z "We said, ""no""." |
true,,-42.1e7,"A to Z" |
42,1 A to Z,1,2,3 |
Format | Null | Boolean true | Boolean false | Integer | Floating-point | String | Array | Associative array/Object |
Ion |
|
true |
false |
685230 -685230 0xA74AE 0b111010010101110 |
6.8523015e5 |
"A to Z" ''' |
[true, null, -42.1e7, "A to Z"]
|
{'42': true, 'A to Z': [1, 2, 3]}
|
Netstringsc | 0:, a4:null, a |
1:1, a4:true, a |
1:0, a5:false, a |
6:685230, a |
9:6.8523e+5, a |
6:A to Z, |
29:4:true,0:,7:-42.1e7,6:A to Z,, |
41:9:2:42,1:1,,25:6:A to Z,12:1:1,1:2,1:3,,,, a |
JSON | null |
true |
false |
685230 -685230 |
6.8523015e+5 |
"A to Z" |
[true, null, -42.1e7, "A to Z"]
|
{"42": true, "A to Z": [1, 2, 3]}
|
OGDL | null a |
true a |
false a |
685230 a |
6.8523015e+5 a |
"A to Z" 'A to Z' NoSpaces |
true null -42.1e7 "A to Z"
|
42 true "A to Z" 1 2 3 42 true "A to Z", (1, 2, 3) |
Format | Null | Boolean true | Boolean false | Integer | Floating-point | String | Array | Associative array/Object |
OpenDDL | ref {null} |
bool {true} |
bool {false} |
int32 {685230} int32 {0x74AE} int32 {0b111010010101110} |
float {6.8523015e+5} |
string {"A to Z"} |
Homogeneous array:
int32 {1, 2, 3, 4, 5} Heterogeneous array: array { bool {true} ref {null} float {-42.1e7} string {"A to Z"} } |
dict { value (key = "42") {bool {true}} value (key = "A to Z") {int32 {1, 2, 3}} } |
PHP serialization format | N; |
b:1; |
b:0; |
i:685230; i:-685230; |
d:685230.15; dd:INF; d:-INF; d:NAN; |
s:6:"A to Z"; |
a:4:{i:0;b:1;i:1;N;i:2;d:-421000000;i:3;s:6:"A to Z";} |
Associative array:a:2:{i:42;b:1;s:6:"A to Z";a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}} Object: O:8:"stdClass":2:{s:4:"John";d:3.14;s:4:"Jane";d:2.718;} d |
Pickle (Python) | N. |
I01\n. |
I00\n. |
I685230\n. |
F685230.15\n. |
S'A to Z'\n. |
(lI01\na(laF-421000000.0\naS'A to Z'\na. |
(dI42\nI01\nsS'A to Z'\n(lI1\naI2\naI3\nas. |
Property list (plain text format)[10] |
N/A | <*BY> |
<*BN> |
<*I685230> |
<*R6.8523015e+5> |
"A to Z" |
( <*BY>, <*R-42.1e7>, "A to Z" ) |
{ "42" = <*BY>; "A to Z" = ( <*I1>, <*I2>, <*I3> ); } |
Property list (XML format)[11][12] |
N/A | <true /> |
<false /> |
<integer>685230</integer> |
<real>6.8523015e+5</real> |
<string>A to Z</string> |
<array>
<true />
<real>-42.1e7</real>
<string>A to Z</string>
</array>
|
<dict>
<key>42</key>
<true />
<key>A to Z</key>
<array>
<integer>1</integer>
<integer>2</integer>
<integer>3</integer>
</array>
</dict>
|
Protocol Buffers | N/A | true |
false |
685230 -685230 |
20.0855369 |
"A to Z" |
field1: "value1" field1: "value2" field1: "value3 anotherfield { foo: 123 bar: 456 } anotherfield { foo: 222 bar: 333 } |
thing1: "blahblah"
thing2: 18923743
thing3: -44
thing4 {
submessage_field1: "foo"
submessage_field2: false
}
enumeratedThing: SomeEnumeratedValue
thing5: 123.456
[extensionFieldFoo]: "etc"
[extensionFieldThatIsAnEnum]: EnumValue
|
Format | Null | Boolean true | Boolean false | Integer | Floating-point | String | Array | Associative array/Object |
S-expressions | NIL nil |
T #t ftrue |
NIL #f ffalse |
685230 |
6.8523015e+5 |
abc "abc" #616263# 3:abc {MzphYmM=} |YWJj| |
(T NIL -42.1e7 "A to Z") |
((42 T) ("A to Z" (1 2 3))) |
YAML | ~ null Null NULL [13] |
y Y yes Yes YES on On ON true True TRUE [14] |
n N no No NO off Off OFF false False FALSE [14] |
685230 +685_230 -685230 02472256 0x_0A_74_AE 0b1010_0111_0100_1010_1110 190:20:30 [15] |
6.8523015e+5 685.230_15e+03 685_230.15 190:20:30.15 .inf -.inf .Inf .INF .NaN .nan .NAN [16] |
A to Z "A to Z" 'A to Z' |
[y, ~, -42.1e7, "A to Z"]
- y - - -42.1e7 - A to Z |
{"John":3.14, "Jane":2.718}
42: y A to Z: [1, 2, 3] |
XMLe and SOAP | <null /> a |
true |
false |
685230 |
6.8523015e+5 |
A to Z |
<item>true</item>
<item xsi:nil="true"/>
<item>-42.1e7</item>
<item>A to Z<item>
|
<map>
<entry key="42">true</entry>
<entry key="A to Z">
<item val="1"/>
<item val="2"/>
<item val="3"/>
</entry>
</map>
|
XML-RPC | <value><boolean>1</boolean></value> |
<value><boolean>0</boolean></value> |
<value><int>685230</int></value> |
<value><double>6.8523015e+5</double></value> |
<value><string>A to Z</string></value> |
<value><array>
<data>
<value><boolean>1</boolean></value>
<value><double>-42.1e7</double></value>
<value><string>A to Z</string></value>
</data>
</array></value>
|
<value><struct>
<member>
<name>42</name>
<value><boolean>1</boolean></value>
</member>
<member>
<name>A to Z</name>
<value>
<array>
<data>
<value><int>1</int></value>
<value><int>2</int></value>
<value><int>3</int></value>
</data>
</array>
</value>
</member>
</struct>
|
- a. ^ Omitted XML elements are commonly decoded by XML data binding tools as NULLs. Shown here is another possible encoding; XML schema does not define an encoding for this datatype.
- b. ^ The RFC CSV specification only deals with delimiters, newlines, and quote characters; it does not directly deal with serializing programming data structures.
- c. ^ The netstrings specification only deals with nested byte strings; anything else is outside the scope of the specification.
- d. ^ PHP will unserialize any floating-point number correctly, but will serialize them to their full decimal expansion. For example, 3.14 will be serialized to 3.140000000000000124344978758017532527446746826171875.
- e. ^ XML data bindings and SOAP serialization tools provide type-safe XML serialization of programming data structures into XML. Shown are XML values that can be placed in XML elements and attributes.
- f. ^ This syntax is not compatible with the Internet-Draft, but is used by some dialects of Lisp.
Comparison of binary formats
Format | Null | Booleans | Integer | Floating-point | String | Array | Associative array/Object |
---|---|---|---|---|---|---|---|
ASN.1 (BER, PER or OER encoding) |
NULL type | BOOLEAN:
|
INTEGER:
|
REAL:
base-10 real values are represented as character strings in ISO 6093 format; binary real values are represented in a binary format that includes the mantissa, the base (2, 8, or 16), and the exponent; the special values NaN, -INF, +INF, and negative zero are also supported |
Multiple valid types (VisibleString, PrintableString, GeneralString, UniversalString, UTF8String) | data specifications SET OF (unordered) and SEQUENCE OF (guaranteed order) | user definable type |
Binn | \x00 |
True: \x01 False: \x02 |
big-endian 2's complement signed and unsigned 8/16/32/64 bits | single: big-endian binary32 double: big-endian binary64 |
UTF-8 encoded, null terminated, preceded by int8 or int32 string length in bytes | Typecode (one byte) + 1-4 bytes size + 1-4 bytes items count + list items | Typecode (one byte) + 1-4 bytes size + 1-4 bytes items count + key/value pairs |
BSON | \x0A (1 byte) |
True: \x08\x01 False: \x08\x00 (2 bytes) |
int32: 32-bit little-endian 2's complement or int64: 64-bit little-endian 2's complement | double: little-endian binary64 | UTF-8 encoded, preceded by int32 encoded string length in bytes | BSON embedded document with numeric keys | BSON embedded document |
Concise Binary Object Representation (CBOR) | \xf6 (1 byte) |
True: \xf5 False: \xf4 (1 byte) |
Small positive/negative \x00-\x17 & \x20-\x37 (1 byte)8-bit: positive |
IEEE half/single/double \xf9 - \xfb (+2-8 bytes)Decimals and bigfloats (4+ bytes) encoded as |
Length and content (1-9 bytes overhead) Bytestring |
Length and items \x80 - \x9e Indefinite list |
Length (in pairs) and items \xa0 - \xbe Indefinite map |
Efficient XML Interchange (EXI)[lower-alpha 1] (Unpreserved lexical values format) |
xsi:nil is not allowed in binary context | 1-2 bit integer interpreted as boolean. | Boolean sign, plus arbitrary length 7-bit octets, parsed until most-significant bit is 0, in little-endian. The schema can set the zero-point to any arbitrary number. Unsigned skips the boolean flag. |
Float: integer mantissa and integer exponent. Decimal: boolean sign, integer whole value, integer fractional |
Length prefixed Integer-encoded Unicode. Integers may represent enumerations or string table entries instead. | Length prefixed set of items. | Not in protocol. |
FlatBuffers | Encoded as absence of field in parent object | True: one byte \x01 False: \x00 |
little-endian 2's complement signed and unsigned 8/16/32/64 bits | floats: little-endian binary32
doubles: little-endian binary64 |
UTF-8 encoded, preceded by 32 bit integer length of string in bytes | Vectors of any other type, preceded by 32 bit integer length of number of elements | Tables (schema defined types) or Vectors sorted by key (maps / dictionaries) |
Ion[17] | \x0f [lower-alpha 2] |
True: \x11 False: |
positive \x2x , negative \x3x Zero is always encoded in tag byte |
\x44 (32-bit float)\x48 (64-bit float)Zero is always encoded in tag byte |
UTF-8: \x8x Other strings: |
\xbx Arbitrary length and overhead. Length in octets. |
Structs (numbered fields): \xdx Annotations (named fields): |
MessagePack | \xc0 |
True: \xc3 False: \xc2 |
Single byte "fixnum" (values -32..127)
or typecode (one byte) + big-endian (u)int8/16/32/64 |
Typecode (one byte) + IEEE single/double | Typecode + up to 15 bytes or typecode + length as uint8/16/32 + bytes; encoding is unspecified[18] |
As "fixarray" (single-byte prefix + up to 15 array items)
or typecode (one byte) + 2–4 bytes length + array items |
As "fixmap" (single-byte prefix + up to 15 key-value pairs)
or typecode (one byte) + 2–4 bytes length + key-value pairs |
Netstrings[lower-alpha 3] | Not in protocol. | Not in protocol. | Not in protocol. | Length encoded as an ASCII string + ':' + data + ',' Length counts only octets between ':' and ',' |
Not in protocol. | Not in protocol. | Not in protocol. |
OGDL Binary | |||||||
Property list (binary format) |
|||||||
Protocol Buffers | Variable encoding length signed 32-bit: varint encoding of "ZigZag"-encoded value (n << 1) XOR (n >> 31)
Variable encoding length signed 64-bit: varint encoding of "ZigZag"-encoded |
floats: little-endian binary32
doubles: little-endian binary64 |
UTF-8 encoded, preceded by varint-encoded integer length of string in bytes | Repeated value with the same tag
or, for varint-encoded integers only, values packed contiguously and prefixed by tag and total byte length |
N/A | ||
Recursive Length Prefix | Not in protocol.
|
Not in protocol. Integer 0/1 often used. |
0 - 127: \x00 - \x7f Other values: Strings of big-endian encoded bytes, of arbitrary length, beginning with |
Integer encodings may be interpreted as IEEE float. | Length prefixed, up to 55 bytes: \x80 - \xb7 followed by data.56+ bytes: |
Length prefixed, up to 55 bytes: \xc0 - \xf7 followed by data.56+ bytes: |
Not in protocol. May be encoded as lists of key/value pair lists or other formats. |
Smile | \x21 |
True: \x23 False: \x22 |
Single byte "small" (values -16..15 encoded using \xc0 - \xdf ),
zigzag-encoded |
IEEE single/double, BigDecimal |
Length-prefixed "short" Strings (up to 64 bytes), marker-terminated "long" Strings and (optional) back-references | Arbitrary-length heterogenous arrays with end-marker | Arbitrary-length key/value pairs with end-marker |
Structured Data eXchange Formats (SDXF) | big-endian signed 24-bit or 32-bit integer | big-endian IEEE double | either UTF-8 or ISO 8859-1 encoded | list of elements with identical ID and size, preceded by array header with int16 length | chunks can contain other chunks to arbitrary depth | ||
Thrift |
- Any XML based representation can be compressed, or generated as, using EXI - Efficient XML Interchange, which is a "Schema Informed" (as opposed to schema-required, or schema-less) binary compression standard for XML.
- All basic Ion types have a null variant, as its 0xXf tag. Any tag beginning with 0x0X other than 0x0f defines ignored padding.
- Interpretation of Netstrings is entirely application- or schema-dependent
References
- "HAPI FHIR - The Open Source FHIR API for Java". hapifhir.io.
- https://thrift.apache.org/
- "A Brief History of SOAP". www.xml.com.
- Ben-Kiki, Oren; Evans, Clark; Net, Ingy döt (2009-10-01). "YAML Ain't Markup Language (YAML) Version 1.2". The Official YAML Web Site. Retrieved 2012-02-10.
- "text_format.h - Protocol Buffers". Google Developers.
- "Cap'n Proto serialization/RPC system: core tools and C++ library - capnproto/capnproto". 2 April 2019 – via GitHub.
- "Cap'n Proto: The capnp Tool". capnproto.org.
- "Fast Binary Encoding is ultra fast and universal serialization solution for C++, C#, Go, Java, JavaScript, Kotlin, Python, Ruby: chronoxor/FastBinaryEncoding". 2 April 2019 – via GitHub.
- "Avro Json Format".
- "NSPropertyListSerialization class documentation". www.gnustep.org. Archived from the original on 2011-05-19. Retrieved 2009-10-28.
- "Documentation Archive". developer.apple.com.
- "Documentation Archive". developer.apple.com.
- Oren Ben-Kiki; Clark Evans; Brian Ingerson (2005-01-18). "Null Language-Independent Type for YAML Version 1.1". YAML.org. Retrieved 2009-09-12.
- Oren Ben-Kiki; Clark Evans; Brian Ingerson (2005-01-18). "Boolean Language-Independent Type for YAML Version 1.1". YAML.org. Clark C. Evans. Retrieved 2009-09-12.
- Oren Ben-Kiki; Clark Evans; Brian Ingerson (2005-02-11). "Integer Language-Independent Type for YAML Version 1.1". YAML.org. Clark C. Evans. Retrieved 2009-09-12.
- Oren Ben-Kiki; Clark Evans; Brian Ingerson (2005-01-18). "Floating-Point Language-Independent Type for YAML Version 1.1". YAML.org. Clark C. Evans. Retrieved 2009-09-12.
- http://amzn.github.io/ion-docs/docs/binary.html
- "MessagePack is an extremely efficient object serialization library. It's like JSON, but very fast and small.: msgpack/msgpack". 2 April 2019 – via GitHub.