bibiver

Landing page with examples: quixote.bilinearlabs.io

mmm most of writes and reads (if not all) are batched, meaning a leaf insert triggers just a batched write (containing all updates). maybe there is some fine tunning to be made.

by now sequential, but we are working on it. unsure though which concurrency model to choose tbh.

open to integrate async storage backends. do you have one in mind? more benchmarks coming.

We've just released rs-merkle-tree, a Merkle tree crate designed with performance and modularity in mind. It comes with the following key features:

* Fixed depth: All proofs have a constant size equal to the depth of the tree. The depth can be configured via a const generic.

* Append-only: Leaves are added sequentially starting from index 0. Once added, a leaf cannot be modified.

* Optimized for Merkle proof retrieval: Intermediate nodes are stored so that proofs can be fetched directly from storage without recomputation, resulting in very fast retrieval times.

* Configurable storage and hash functions: Currently supports Keccak and Poseidon hashers, and in-memory, Sled, RocksDB, and SQLite stores.

The Rust ecosystem already offers several Merkle tree implementations, but rs-merkle-tree is built for a specific use case: append-only data structures such as blockchains, distributed ledgers, audit logs, or certificate transparency logs. It’s particularly optimized for proof retrieval, storing intermediate nodes in a configurable and extensible storage backend so they don’t need to be recomputed when requested.

I saw this and was like, what?

> have we advanced much in 30 years?

IDEs have changed a lot, specially with AI-assisted ones. The author kind of acknowledges it, but imho it's a paradigm shift. Not just "a major difference".

> The only major difference that we are starting to see might be AI-assisted coding, but this is a feature mostly provided by a remote service, not even by the installed code!

Then I realized it’s a post from 2023. IDEs have changed a lot since then. Autocompletion has evolved from merely suggesting function names to completing 20 lines of code in the blink of an eye. It's great for productivity, but it also makes you lazy, to the point where you can't live without it.

In my opinion, software engineers should “disable the autopilot” from time to time, just like airline pilots must occasionally land without it. Otherwise, you end up becoming too dependent on it.