MobX is mainly sponsored by Coinbase, Mendix, open-source of Facebook, Canva, Guilded, Algolia, Auction Frontier, TalentPlot for about 100$ per month or at times even more! Also, beyond this many individual backers have given one-time contributions. It is great to know that the philosophy behind the MobX is quite simple:

Anything which may be derived from the state of application should be even automatically derived that includes UI, server communication, data serialization, and others.

–    Support of Browser

MobX >=5 it can run on any browser having the support of ES6 proxy. It may then throw an error for the startup of the older atmosphere like IE11, Node.js <6 and it might also React Native Android upon the older JavaScriptCore about how you can upgrade.

MobX 4 usually runs on the browser of ES5 and it will also be maintained actively. The MobX 4, as well as the 5 APIs, are the same as well as semantically they may simply achieve the same, however, MobX 4 also has some kind of limitations.

–    Tip:

The main point of entry of MobX 5 package and ships with code of ES5 for the backward compatibility has various build tools. However, as MobX 5 usually runs only on modern browsers, consider using fast and small ES6 build:

MobX and React together are known to be an influential combination. The React usually renders the state of the application by offering the mechanisms that could translate in the tree of components that are rendered able. Moreover, MobX offers a mechanism for storing and updating the state of application which is then used by React.

Both MobX and React offer unique and optimal solutions for the common problems in the development of the application. However, React offers mechanisms that could optimally render the UI through using the virtual DOM which helps to reduces the number of the most expensive DOM mutations. MobX offers the mechanisms for optimally synchronize the application state through the React components through using the reactive through the virtual dependency and state graph which is just updated while strictly required and does not get stale.

–    How does MobX react?

Why the new message does get printed whenever unfinished for doing Count gets changed? Here, the answer is quite simple as per the thumb rule.

MobX usually reacts to the existing noticeable property which is read at the time of execution of the tracked function. Having a complete and in-depth explanation about the fact that how MobX identifies to which observables require to get reacted, you need to also check and understand that what does MobX reacts to.

Unlike various frameworks of flux, MobX is not opinionated about the fact that how the user events must get handled as this may be simply done in the Flux manner, or it could be done through processing events with the use of RxJS, or by just handling the events in various straightforward possible way. Also, in end it will boil down and also somehow state must get updated.

Subsequent to updating state MobX it will take complete care of rest in most efficient as well as glitch-free way. Hence as per the simple statements, like it is mentioned below, are actually adequate to update the user interface automatically.

There is not any technical requirement for the firing events, known as the dispatcher and other additional things. The React component at the end certainly is nothing more as compared to the fancy representation of the state. The derivation will be managed perfectly by the MobX.

On the other hand, MobX also has a voluntary built-in concept related to the actions. It’s quite simple! Use them for your benefit; they would even help to structure the code better and also make wise decisions and also when and where the state must get modified.

–    MobX: Scalable and Simple

MobX is the least conspicuous libraries that you may simply use for the state management. This makes the MobX approach is not only simple, but it is quite scalable:

– Using real and classes references

In MobX you do not require to normalize the data. It makes the library to be much suitable and appropriate for complex models of domain. At Mendix about 500 diverse domain classes are available in the single application.

– Referential reliability is assured

As the data doesn’t require to get normalized, and even MobX will track the relationship automatically between the derivation and state, you also get the referential integrity for completely free. Rendering something which is considered to be accessed through three different levels related to indirection?

There is not any problem, MobX will keep track and even re-render at any point in time about the changes in the references. As a result of the staleness, bugs are the crucial thing about the past. As the programmer, you may even forget about changing some of the data that could influence the seemingly unconnected component in the corner case. Here, MobX will never forget.

Simple actions are easy to sustain

As it is earlier demonstrated, modifying the state while using the MobX is quite much straightforward. You just need to write down the intentions and MobX will take the best care about the rest of the things.

Finely grained observability is highly efficient!

MobX usually builds the graph of various derivations in the application to search the least number of the re-computations which is required for preventing staleness. “Derive everything” may also sound to be expensive; MobX creates the virtual graph derivation to diminish a number of computations that are required to keep the derivations in perfect sync with the state.

However, while testing the MobX at Mendix we usually found that using the library for tracking the relations in the code is quite often efficient as compared to pushing of the changes through the application through using the handwritten events and “smart” container components that are selector based.


MobX is the library that is battle-tested and that makes the state management to be quite much simple as well as scalable by applying the TFRP also known as transparently functional reactive programming.