baobab

The reactive data store bits seem very similar to baobab.js [0]. Baobab's api seems a bit more terse though, which I prefer. [0] https://github.com/Yomguithereal/baobab

There's also Baobab: https://github.com/Yomguithereal/baobab https://github.com/Yomguithereal/baobab-react

I've been using baobab[1] which is: > a JavaScript persistent and immutable (at least by default) data tree supporting cursors and enabling developers to easily navigate and monitor nested data through events. It's a fairly simple library to read and understand and it's well written. I have a couple decent sized SPAs working on top of it, and I store the full data tree using localForage for offline use. 1: https://github.com/Yomguithereal/baobab

There is Baobab[1] - it is a single state-tree approach, while supporting computed values in the tree and has a react adapter[2]. [1]: https://github.com/Yomguithereal/baobab#computed-data-or-mon... [2]: https://github.com/Yomguithereal/baobab-react

I've used it on a few personal projects with a koa powered API on the backend and one smaller project at work. I like it a lot, I've tried angular and jquery as well, both really don't stack up at all. One thing that I wish was different was the focus on using flux. Flux isn't really for me, I found it really complicated and it made following the data through my app even more complicated than it was with angular. The solution for me was to use something like Om's cursors (specifically baobab https://github.com/Yomguithereal/baobab). After trying to get a handle on flux for a few days I switched to baobab and the real power of reactjs just clicked for me.

So Reagent is like React + Baobab (https://github.com/Yomguithereal/baobab)? Since Clojurescript has to compile to Javascript anyway, I can't think of a reason why Javascript can't have a counterpart to Reagent. I'm not familiar with Clojure, but it seems like atom is the data tree that holds the state of the entire application. If so, could you give an example use case of when you'd pass the data tree between threads, and what advantages it has over promises or es7 async/await. Just to be sure, I'm not questioning the validity of your claims, I'm genuinely curious about how things work in reagent.

This looks great. I think it deserves more examples though. Looking again, I see from the commits that you've already been working on the docs. Again, great! I may give this a try in my toy project. Edit: I'm currently using Baobab[1] to manage state in a React app and I'm thinking about writing an adapter for it. I wonder if that makes sense. I'm leaning towards "yes". [1]: https://github.com/Yomguithereal/baobab

I believe the idiomatic way to use this library is to treat the tree as an immutable structure. When used this way, it supports the React Immutability Helpers, and the PureRenderMixin. If you treat it as immutable and use the PureRenderMixin, you won't run into the re-render multiple times issue described above. See this issue for more details: https://github.com/Yomguithereal/baobab/pull/74

Baobab should at least in part mitigate this by not committing changes immediately, but rather in batches as a single change: https://github.com/Yomguithereal/baobab/wiki/Options "When you use the mutation methods of Baobab (push, set, merge etc.) it will batch up these changes and make one single commit, which then triggers update events." I haven't worked with Om on a non-trivial project yet, so please correct me if I'm wrong, but I believe Om might also do similar optimizations (i.e. batching updates and sending notifications in sync with its render on requestAnimationFrame flow).