diff-match-patch VS zstd

I also came across this diff match algorithms: https://github.com/google/diff-match-patch

Outside of that, to get the diffs there is a library called diff-match-patch that has implementations in most languages. Your data model / state tracking sounds like it matches the internal constraints.

So I'll just leave you with this question - why, as a developer, would I ever advise using this, when fast diff is an industry standard tool that does exactly this, but better, using well tested methods that are being implemented in JS and further optimized by one of the largest global tech companies. Mind you, this is the same company which has developed its own proprietary monolithic VCS, managing versioning for 2billion+ lines of code.

Hello HN!

I was always annoyed by conflicts that can be solved automatically, but still need human intervention. E.g. two people changing the same line, but at different, non-conflicting positions. So I searched for a character based patching library and found this nice article https://neil.fraser.name/writing/patch/ and its corresponding library https://github.com/google/diff-match-patch.

Parsing git conflicts, applying patches and showing some useful diffs in the UI helps me to solve 80% of my conflicts automatically. I hope it can help you too.

Happy Hacking!

A bit late to the party but have you checked this? google/diff-match-patch

Found this, simple and seems interesting: https://github.com/google/diff-match-patch

If you need to know exactly what the diff is, you might want to use something like github.com/google/diff-match-patch. Otherwise, a simple Levenshtein distance would suffice. This library seems to have a whole bunch of string distances implemented. Hope this helps!

Photo by Markus Spiske on Diff.Match.Patch based on Google library.

I don't think so? It's only seekable with an additional index [1], just like any other compression scheme.

[1] https://github.com/facebook/zstd/blob/dev/contrib/seekable_f...

- latest zstd v1.5.6 ( Mar 30, 2024 https://github.com/facebook/zstd/releases )

You may have also noticed that a new supported data compression format zstd appeared some time ago. I haven't seen any backends that use it yet, but httpx will support decompression in versions above 0.28.0. I already use it to compress server response dumps in my projects; it shows incredible efficiency in asynchronous solutions with aiofiles.

Zstd is a personal project? Surely it's not by accident in the Facebook GitHub organization? And that you need to sign a contract on code.facebook.com before they'll consider merging any contributions? That seems like an odd claim, unless it used to be a personal project and Facebook took it over

(https://github.com/facebook/zstd/blob/dev/CONTRIBUTING.md#co...)

Unmount root and remount the subvolumes and the boot partition. noatime is used for better performance zstd as file compression:

> In such cases, the serialized binary are mostly in 200~1000 bytes. Not big enough for zstd to work

You're not referring to the same dictionary that I am. Look at --train in [1].

If you have a training corpus of representative data, you can generate a dictionary that you preshare on both sides which will perform much better for very small binaries (including 200-1k bytes).

If you want maximum flexibility (i.e. you don't know the universe of representative messages ahead of time or you want maximum compression performance), you can gather this corpus transparently as messages are generated & then generate a dictionary & attach it as sideband metadata to a message. You'll probably need to defer the decoding if it references a dictionary not yet received (i.e. send delivers messages out-of-order from generation). There are other techniques you can apply, but the general rule is that your custom encoding scheme is unlikely to outperform zstd + a representative training corpus. If it does, you'd need to actually show this rather than try to argue from first principles.

[1] https://github.com/facebook/zstd/blob/dev/programs/zstd.1.md

> Doesn't take large amount of GPU resources

This is an understatement, zstd dictionary compression and decompression are blazingly fast: https://github.com/facebook/zstd/blob/dev/README.md#the-case...

My real-world use case for this was JSON files in a particular schema, and the results were fantastic.

This VFS will read a sqlite file after it has been compressed using [zstd seekable format](https://github.com/facebook/zstd/blob/dev/contrib/seekable_f...). Built to support read-only databases for full-text search. Benchmarks are provided in README.

Of course, you may get different results with another dataset.

gzip (zlib -6) [ratio=32%] [compr=35Mo/s] [dec=407Mo/s]

zstd (zstd -2) [ratio=32%] [compr=356Mo/s] [dec=1067Mo/s]

NB1: The default for zstd is -3, but the table only had -2. The difference is probably small. The range is 1-22 for zstd and 1-9 for gzip.

NB2: The default program for gzip (at least with Debian) is the executable from zlib. With my workflows, libdeflate-gzip iscompatible and noticably faster.

NB3: This benchmark is 2 years old. The latest releases of zstd are much better, see https://github.com/facebook/zstd/releases

For a high compression, according to this benchmark xz can do slightly better, if you're willing to pay a 10× penalty on decompression.

xz -9 [ratio=23%] [compr=2.6Mo/s] [dec=88Mo/s]

zstd -9 [ratio=23%] [compr=2.6Mo/s] [dec=88Mo/s]