[irq-1]

Seems like this only helps large (heavy) websites with consistent content. The real world examples are all large, like YouTube, Amazon, etc...

Small JSON responses that compress to <1k would fit in a single packet, so I don't see the advantage of going from "65 bytes with normal Zstandard compression, vs 28 bytes when using the past response as a dictionary - 57% smaller."

[cyanydeez]

The toy examples aren't the savings. Do the calculations with a json list of 100 objects and you'll find that compress increase more significantly.

So yeah, one time object return isn't impressive. Once those objects are in an array, then there's a much more remarkable compression.

While reading, I started wondering if we'll see an LLM constructor that'll take a API and some actual browser use and create a model that maximizes these types of message-centric compression.

[gnotstic]

yes i was under the same impression, but i think this LUT/dictionary solution is counter intuitive to both of our current understandings of the web.

The "aha" moment for me was that, without this dict, the user is going to always request a full download of the data. For instance, let's say the NYT published an article and you read it. Then an editors note is added to the article. When you go back to read the article, the data transfer is miniscule. Now that is an edge case, but imagine a website that allows comments.. twitter.. reddit.. small text based pages that at first seem incosequential until you think about how we use the web, millions of users, returning to pages over and over again.

For me, my mental model of this structure is a LUT(key/value pair) wrapped in a Version Control(hash).

Now i think your comment is correct if we were to add how many requests the webpage is recieving and how frequently changes are happening to said webpage. My blog would recieve no benefits from implementing this tech, and using napkin math, my blog would need 1000 days to break even. Microsofts' blog however... less than a day, in theory.

[everforward]

If the version control hash changes you have to re-download the dictionary, which is similar to redownloading the whole page.

Reddit/NYT would have to publish their changes without changing the dictionary, meaning some portions would be largely absent from the dictionary and have worse compression than gzip. Probably fine for NYT, something like Reddit might actually have worse ratios than gzip in that case.

[superb_dev]

Or you could use the previous version to generate the dictionary for the current version?

I would assume chunks that didn’t benefit from the dictionary would receive the standard compression, so you can’t get worse than gzip.

[everforward]

Maybe? That gets sort of awkward for frequently updated things like Reddit where there might be 10 dictionary versions between what you have and the current version. You’d need something that decides whether to get an incremental update or a new dictionary, and the hoster has to store those old dictionaries. Feels like more trouble than it’s worth.

You could compress things with gzip if the dictionary doesn’t work well, but to my understanding gzip compresses repetition. There’s less repetition in smaller chunks, so worse compression ratios. Eg compressing each comment individually has a worse net ratio than compressing all the comments at once.

It would also be annoying to merge a bunch of individually compressed blocks back together, but certainly an option

[superb_dev]

I’m pretty sure the dictionary just gets put on the front of the compression algorithm’s “context” so that it can be referenced just like any other part of the document. You wouldn’t need individual blocks with different compression schemes, it would all get compressed together.