Software dev blog
Today we'll be talking about fractional indexes, how to scale them to efficiently support millions of entries with minimal memory footprint and how to encode them efficiently. We'll also cover some domain-specific ideas that you may find novel. What is a fractional index While it
Ysr  (read:  wiser ) is yet another implementation of Yjs/Yrs Conflict-free Replicated Data Type libraries, used for building collaborative applications. The twist here is that this time we're moved from in-memory database into one that lies natively on disk. This way we hope to
As we're approaching the new major version of Yjs (v14), there are few breaking changes worth talking about. While most of them concern the API, a binary format itself remains stable (so don't be afraid, your document state will still be parseable). But let's
In this blog post we'll going to introduce a new data serialization format. This one focuses on enabling decoding objects as series of incremental object changes, which can be streamed over and emitted/applied partially over time. It could be used in scenarios such as database replication or
This time we're going to cover a new implementation of persistent key value store, using Conflict-free Replicated Data Types (CRDTs) to enable multi-process writes. Moreover, this approach enables shift of replication protocol from custom made gossip servers into passive replicated storage such as iCloud or Google
While you may hear a lot of harsh words about Rust is this rant, that doesn't have to mean it's a bad language. Rephrasing the classic: there are two types of programming languages: ones that people complain about and ones that nobody uses. I've
In this blog post we'll discuss challenges and solutions for concurrent reading from massive amount of Redis streams without running into limitations of the Redis protocol or our machine resources. First let's describe our problem. We could phrase it as follows: we have a number of
In this blog post we'll design a collaborative 2D table structure using yrs - Rust port of popular yjs conflict-free replicated data types library for creating real-time, local-first apps. We'll also cover some optimizations to improve scalability of our solution. Over the years I&
Today we're going to jump into LSeq - one of the famous text-editing conflict-free replicated data types we briefly introduced in the past blog posts. This time we're aiming for fixing one of the popular issues that this algorithm struggles with. We're going
Today we'll explain how do modern databases allow us to perform backups without blocking - thus enabling users to operate on them while the backup is beign made continuously in the background. We'll also show how this approach allow us to restore database to any point in
In this blog post we're going to cover a concepts and implementation behind collaborative 2-dimensional tables, with set of operation that could make them useful to work as spread sheets - popular in products like MS Excel or Google Sheets. There are many open source and commercial alternatives
... or how to make a non-deterministic functions deterministic through the power of isolated WASM sandbox. This time we'll go through the problems of unpredictability in code, which execution could be affected by external factors like I/O operations, time etc. Then we'll see what kind
This blog post is a short summary of ecosystem and capabilities of Yrs (read: wires ): a fully-compatible Rust port of Yjs library used to build collaborative peer-to-peer applications thanks to the power of Conflict-free Replicated Data Types. They are being used and adopted in many different
Today we're going to continue exploration of Conflict-free Replicated Data Types domain. This time we'll start designing protocols that focus on a security aspects as first class citizens. Managing security and permissions in peer-to-peer systems may be quite cumbersome as often there'
Some time ago, we covered an idea behind HyParView , a cluster membership protocol that allowed for very fast and scalable cluster construction. It did so by using the concept of partial view: while our cluster could be build out of thousands of nodes, each one of them would only be