electric VS readyset

I'm interested in this problem also!

I think there is a large overlap with projects that market/focus on offline-first experiences.

AFAIK this problem can be solved by:

1) Considering a client-side copy of the database that gets synced with the remote DB. This is an approach [PowerSync](https://www.powersync.com/) and [ElectricSql](https://electric-sql.com/) and [rxdb](https://rxdb.info/) take!

Yeah I agree with it being an exaggeration. They are certainly riding the admittedly dated perception that realtime is so hard it's only available to the Googles and Figmas. But there's now some amazing open source solutions available like Y.js and ElectricSQL[1]. The barrier has certainly come down.

[1] https://github.com/electric-sql/electric

https://github.com/electric-sql/electric :

> ElectricSQL is a local-first software platform that makes it easy to develop high-quality, modern apps with instant reactivity, realtime multi-user collaboration and conflict-free offline support.

> Local-first is a new development paradigm where your app code talks directly to an embedded local database and data syncs in the background via active-active database replication. Because the app code talks directly to a local database, apps feel instant. Because data syncs in the background via active-active replication it naturally supports multi-user collaboration and conflict-free offline

"SQLedge: Replicate Postgres to SQLite on the Edge" (2023)

Yup, this is correct.

We have had some requests / discussions around adding hooks to the sync service that will support custom logic on the write path (as per https://github.com/electric-sql/electric/discussions/565). This seems like a good idea but they don't exist yet.

- Some platforms like Supabase Realtime [3] and Firebase offer subscription models to database changes, but these solutions fall short when dealing with complex queries involving joins or group-bys.

My vision is that the modern frontend to behave like a series of materialized views that dynamically update as the underlying data changes. Current state management libraries handle state trees well but don't seamlessly integrate with relational or graph-like database structures.

The only thing I can think of is to implement it by myself, which sounds like a big PITA.

Anything goes, Brainstorm with me. Is it causing you headaches as well? Are you familiar with an efficient solution? how are you all tackling it?

[1] https://readyset.io/

Postgresql + MySQL Cache https://github.com/readysettech/readyset

I just wanted to give a high five for having Jepsen tests for this: https://github.com/readysettech/readyset/tree/stable-240117/...

This example is a great use case for partial incremental view maintenance systems like ReadySet: you automatically get something like the “prepopulating the cache” section (toward the end of the blog) while only caching the data the application is using, and avoiding the need to manually implement any sort of invalidation logic.

(Disclaimer: I used to work for them, but don’t anymore. It’s all available for free on GitHub though for anyone interested: https://github.com/readysettech/readyset)

There are systems that will do that for you like https://readyset.io/.

ReadySet

readyset.io is the company that jonhoo was associated with for work on noria

Might be interesting to try out https://readyset.io for this use case.

On the caching topic, I found the ReadySet(né Noria) approach to be extremely interesting.