Make state management simple again: Intro to MobX

https://mobxjs.github.io/mobx/getting-started.html

by mweststrate • 10 years ago

15 11 10 years ago

mobxjs.github.io

lucidrains2• 10 years ago

Been using this a lot recently, love it!

findjashua• 10 years ago

how do you find it compared to redux?

lucidrains2• 10 years ago

haha hey Jash! should just find you some day after work and show you =)

hwdegroot• 10 years ago

There's a similar wuestion here (with a bullet list answer :)) https://discuss.reactjs.org/t/redux-or-mobservable-what-to-c...

dang• 10 years ago

https://news.ycombinator.com/item?id=11181980

cellvia3• 10 years ago

Thank you for sharing this. I have been doing a lot of digging for an upcoming greenfield rewrite of our client side, and mobx+react is now tied w/ me alongside mercury.js, which shares a similarity in using nested observers as the nervous system of the viewstate. Have you had a chance to look at mercury and the way it achieves unidirectionality?

The documentation for mercury is sadly very poor, but the ideas are sound once you "get it"

here is the repo https://github.com/Raynos/mercury/

here are the rough docs https://github.com/Raynos/mercury/tree/master/docs

how would you compare the prescribed method of state management of mobx+react to mercury's immutable observer state-tree that sends observed changes up to the app root, then signals re-render w/ a immutable state emission to a cascade of renders below it?

mweststrate3• 10 years ago

I think it is quite different, at least if I read the docs correctly mercury is much closer to Redux / OM then MobX + React. MobX doesn't work with cursors and your tree doesn't have to be a normalized tree (it can be any (mutable) graph). In MobX data is not pushed through the root (which is when working with large collections still slow!) but rather each components observes exactly its own observables (deeply). This means that children can re-render without their parents and vice versa. This is done automatically and you don't have to write any cursors for it.

I'm not sure whether this answers your question completely, so just let me know if that is the case :)

cellvia3• 10 years ago

This definitely helps, thank you.

I suppose the main similarity is the chain of observables being a nervous system of sorts. In mercury the observers pass the update signal all the way back to root (and then needless re-renders are mitigated by vdom-thunks) , whereas w/ mobx the update signal is not passed up to root, just to the local component in question, and then that re-renders itself, so the rest of the app is not concerned

One cool thing about combining observables AND immutability as in mercury isyou get the equality checking via immutability, but you also get to deal w/ component updates locally. ...no dependence on a global event emitter or global event emitter abstraction like redux.

So 2 questions: w/ mobx + react how do you deal w/ events outside of a component?

And what, if anything, is lost from losing the uni-directionality?

Make state management simple again: Intro to MobX

Related Stories