Show HN: Homogenius – Packer/unpacker to reduce the size of JSON(homogenius.github.io)
homogenius.github.io
Show HN: Homogenius – Packer/unpacker to reduce the size of JSON
http://homogenius.github.io/docs/
31 comments
In most real-world cases, it'll look like this:
Here's the size (in bytes) of the sample files given with the project:
gzip+Homogenius < gzip < Homogenius < original JSON
Here's the size (in bytes) of the sample files given with the project:
69934 packed-homogenius.json.gz
79550 verbose.json.gz
213742 packed-homogenius.json
265177 verbose.jsonI get the same ordering with gzip, but it seems sensitive to compression algorithm. With bzip2 (default settings, v1.0.6), homogenius seems to actually worsen the compression ratio, at least on this one example:
52093 verbose.json.bz2
56298 packed-homogenius.json.bz2
68521 packed-homogenius.json.gz
79222 verbose.json.gz
213742 packed-homogenius.json
265177 verbose.jsonBWT-based compressors like bzip2 do best when their inputs have highly repetitive structure. In a JSON file with many repeated keys, the information that `"k` is usually followed by `ey_1": "` is compressed very effectively. For similar reasons, bzip2 tends to outperform gzip on executables-- it can more effectively model the conditional probability of opcode sequences.
See http://mattmahoney.net/dc/dce.html#Section_55 for more discussion
See http://mattmahoney.net/dc/dce.html#Section_55 for more discussion
You had the same idea as me, I think I posted my edit almost exactly when you posted this!
Interesting to see a similar correlation in your results in the ratio between the two non-gzipped and gzipped files.
Interesting to see a similar correlation in your results in the ratio between the two non-gzipped and gzipped files.
Semi-OT: i am amazed to see how many big sites do not have gzip/deflate compression enabled in their webservers. Especially on mobile connections this can actually make a difference.
[deleted]
I think [Transit][1] by Cognitect addresses this issue as well.
[1]: https://github.com/cognitect/transit-format#caching
[1]: https://github.com/cognitect/transit-format#caching
Actually I'm trying to create a new datatype for homogenous data types, which is prevents repeating keys that happened in JSON datatype.
I think this needs some sort of marker for the compressed form to make it clear it's not to be digested as is. Maybe `$HMGNS$` or something as the first key of the array?
Why not just use MessagePack (aka MsgPack)
http://msgpack.org/
http://msgpack.org/
MsgPack is great, but pure JSON compaction methods like this or transit can be used directly in a browser.
I see two great things about this tool, and not exactly for what it was designed:
1) Fix bandwidth problems caused by API designer laziness.
2) Detect API designer laziness and programmer laziness.
The API designer laziness merits description. Essentially, if you as an API host server are sending back tons of redundant data, you are doing a disservice to your user by not passing references to this data in the first place. The results in your API should either include an entities section or links to retrieve more data. (Note the scale of repeated data I am talking about here are subtrees, not just key/value)
The programmer laziness is when an he just sends back JSON.stringify(someVeryLargeObject), instead of making sure only a minimal object is sent back.
So we can detect this laziness by running this tool and looking for 4x compression gains!
1) Fix bandwidth problems caused by API designer laziness.
2) Detect API designer laziness and programmer laziness.
The API designer laziness merits description. Essentially, if you as an API host server are sending back tons of redundant data, you are doing a disservice to your user by not passing references to this data in the first place. The results in your API should either include an entities section or links to retrieve more data. (Note the scale of repeated data I am talking about here are subtrees, not just key/value)
The programmer laziness is when an he just sends back JSON.stringify(someVeryLargeObject), instead of making sure only a minimal object is sent back.
So we can detect this laziness by running this tool and looking for 4x compression gains!
It's not always lazyness, several small connections can be considered worse than one bigger payload in some scenarii.
There's no universal truth about API design, every case is different.
Sending too much data is often better than having to do many RPC calls. It's the same problem than normalizing/denormalizing DB schemas, except that DB engines are smart (denormalizing can hurt perf) while RPC clients aren't.
Bandwidth issues can be solved well with msgpack too.
You loose in human readability but you win in size.
An interesting project and i think about a lot of uses for it (save bandwith, avoid timeout etc ...)
thks to make it and i will use it (in go i think).
thks to make it and i will use it (in go i think).
So it's a schema plus interned values? Do you think it might be better on real-world data to use just one mapping of value id to value instead of one per column/key?
I really don't see too many use cases here. Both parties have to buy into it, then at that point you might as well use a binary protocol.
For some apps, there are cases where you want to load the entire dataset and then operate over it (see pourover.js http://newsdev.github.io/pourover/ )
Doing this with JSON is a neat idea. I recently learned that Excel workbooks do this using a sharedStrings.xml file in the .xlsx package.
No benchmarking or comparisons with gzip.
Edit: I did a quick test by myself, using the first example but repeated for 10,000 objects:
Interesting to see a ~4x between raw JSON and Homogenius JSON both when compressed and not compressed.