State Management Further On Progress
The most challenging aspect of any program is undoubtedly state administration. That’s why there are so many state management libraries, and there is more every day around (and there are hundreds of “easier reduction” abstractions in npm) including some built on top of others. Given the fact that policy administration is a hard issue, one thing I believe is that we are always over-engineering our approach to the problem.
There is a state management approach that I have been actively attempting to apply when
using React, and this state management strategy has been dramatically improved with the releases of reacting hooks (and major changes to the react context).
We also talk of Respond components as lego components for our applications, and I think somehow that when people hear it, they believe it removes the state dimension. The “power” behind my personal approach to the issue of state management is to think of how the program maps the layout of the tree of the program.
The fact that the reaction reduction fixed the prop drilling issue was one of those aspects that were so successful. It was wonderful to exchange data between various sections of your tree simply by converting your node into the magic connecting feature. The use of reducers / generators of behavior / etc. is also fine.
This is the reason that I only ever used redux on one project: I consistently see developers putting all of their state into redux. Not just global application state, but the local state as well. This leads to a lot of problems, not the least of which is that when you’re maintaining any state interaction, it involves interacting with reducers, action creators/types, and dispatch calls, which ultimately results in having to open many files and trace through the code in your head to figure out what’s happening and what impact it has on the rest of the codebase.
This is fine for a true global state, but it’s a huge problem for a specific state (as if a modal is open or if it is a form input status). It doesn’t scale very well to make matters worse. The larger the submission, the more complicated it becomes. You can certainly host different reducers to manage various parts of your application, but it is not optimal to indirectly traverse all these creators and reducers
Application state in a single object
The fact that all the program knowledge is in a single entity will also trigger other issues even though you don’t use Redux. If a respond receives a new value, all the modules that use it are modified and have to be replaced, even though they are a function that takes only a portion of the data into consideration. It could lead to potential performance issues. The argument, however, is that, you have no issues, if you get your state more logically isolated and put in the reaction tree, closer to where it counts. (React-Redux v6 also attempted to use the solution before they found it would not operate properly on crooks, which forced them to implement another solution for v7.