RxDB VS hotwire-rails

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!

Hey, after I posted that, I went and gave a second look online to see if I could find something that would allow me to develop a local-first app with offline persistence and syncing capabilities.

I ended up finding some possibilities out there that could potentially help me build stuff. One of them is RxDB [1], which offers WebRTC syncing - you'd still need a signaling server, I suppose, but all sensitive information could be synced E2E-encrypted via WebRTC.

Then there's CRDT's [2], which is a universe that turned out to have multiple possibilities that match (at least partially) my needs. In particular, the next thing I want to take a look at is cr-sqlite [3], which might be just thing I needed to kick-off some side-projects.

I'm posting here cause I just found some hope of not needing to build a traditional client-server app and having to deal with all the hassle involved in securing a server (and with fear that my efforts could be not good enough), and I thought someone else could benefit from getting to know these things.

[1] https://rxdb.info/

About a year ago, I discovered a cool offline-first framework called RxDB. Initially, I thought that on the frontend side, this was exactly what I had been searching for over the past years. After tinkering around and even using it in production for some time, I realized that it wasn't well-suited for my intended use. RxDB was initially created as an RxJS layer for PouchDB with a server replication interface. Over time, other storage types besides PouchDB were introduced (e.g., IndexedDB, SQLite) and the replication interface became more sophisticated. The replication interface is really cool and exactly what I wanted. The biggest problem I have with RxDB is that it is so tightly coupled with RxJS. While RxJS is technically very powerful, it offers a dreadful developer experience. It's really hard to understand at first and integrating it into an existing codebase, which isn't using RxJS, is tedious.

Congrats to the team. Once I’ve tried https://rxdb.info/ and it wasn’t funny at all to do the remote replication (PG) and to deal with conflicts. I do need to check this out!

RxDB (Open Source but paid plugins)

Applications generated with Rails 7 will get Turbo and Stimulus (from Hotwire) by default, instead of Turbolinks and UJS. Hotwire is a new approach that delivers fast updates to the DOM by sending HTML over the wire.

For Ajax-y stuff, I am really excited by the new crop of "HTML-as-a-Service" or "HTML-over-the-wire."

https://htmx.org/

https://hotwired.dev/

For all the turbo/stimulus/hotwire mix, you want to add a new feature just for the sake of adding it? or do you have a use case that fits the feature? if you have then you probably already have an implementation with a different technology (stimulus reflex? some custom websockets or ajax implementation? something with anycable?) and you have to check how to migrate from that technology to hotwire. If you just want to use the feature with no real need for it to practice then just pick any tutorial from the internet (like the intro in the official website https://hotwired.dev).

I was recently interested in similar topic. Here are 3 similar solutions I found:

* https://htmx.org/

* https://unpoly.com/

* https://hotwired.dev/

My personal preference is Unpoly (the idea of "layers" is awesome). But the best explanation of concept as a whole (HATEOAS, keeping app state on server using partial page updates, etc) is at HTMX homepage, and in these essays:

* https://htmx.org/essays/hateoas/

* https://htmx.org/essays/locality-of-behaviour/

At the end of 2020 the Basecamp team released a collection of Javascript libraries called Hotwire. Modern web stacks have popularized javascript-rendered front ends and JSON transmissions. Hotwire's primary motivation is to reduce the Javascript footprint and allow application front ends to be created in primarily HTML. It pairs very nicely with the Ruby on Rails ideology and is often demonstrated in that context. I aim to write a series on how Hotwire can be used in any application to simplify development and reduce the need for heavy Javascript downloads. Hotwire currently consists of two javascript libraries: Turbo and Stimulus. The first part of this series introduces Turbo.

I've been doing that a while until I just got sock of the JS spagetti and often duplicated code and went full on Angular CSR and never looked back. That being said, I've been seeing a lot recently about Laravel's Livewire and Symfony and Ruby on Rail's integration with Hotwire (stimulus+turbo).