redux VS effector-react

For the backend, we chose Python, Django Rest Framework. On the frontend, React, Redux, Saga, Sass. Let’s start with the backend, which was managed by Yegor. He writes about the server part of the project himself.

Use types for Redux state slices and action creators

If you are using Redux, then this is a lifesaver. We know Redux reducers can store a lot of data, and if you feed the complete store into any component, it will cause it to re-render anytime anything in that store updates.

State management is one of the useful aspects of most JavaScript frameworks, It is the management of input or data state across multiple data flows across an application. React does have in-built state management capabilities, but you’d rather use Redux or some other state management tool because it’s not the best to work with. Here is an example of state management in Redux:

Redux is a widely adopted library for managing global state in React applications. It follows a centralized store approach, where the entire application state is stored in a single JavaScript object.

redux

Alright, you knew Redux was coming.

Because the application is shared between server and browser, state is as well. If your app has a single source of state as is often the case with Redux, for example, sharing state between server and browser can be as simple as passing your state object through JSON.stringify() then adding it to a

Redux Documentation: The official Redux documentation covers everything you need to know about using Redux with React.

Next.js documentation on data fetching and state Next.js documentation on server components Redux documentation Next.js Redux Wrapper documentation

Actually, Svelte uses Effector for state management under the hood. You can read more about it here: https://effector.dev/. It also has bindings for other frameworks including React, Vue and Solid. Effector is a little not beginner-friendly, but once you truly understand it, Effector becomes a very powerful.

Effector it is the another way to create state and business logic for your frontend application.

https://effector.dev/ here you go

Where’s effector?

https://ngneat.github.io/elf/ https://effector.dev/

EffectorJS

https://effector.dev/ We use it on production in several projects

To understand this part of the article, it is better to read Effector’s documentation first. Effector has a game-changer feature — Fork API. To understand it, we should talk about one important concept — scope.

The issue with using eventemitter for state coordination is that when the UI grows into complexity you run into race conditions where some component isn't showing the right data because it got mounted too late or something somewhere up the hierarchy changed a key and the component got recreated and its state got lost.

I guess as long as long as the component hierarchy fits in your head, it is likely straightforward to reason about all the event interactions.

The lifted state model ala redux (and similar alternatives) doesn't suffer from this problem.

I personally prefer effector [1] these days because it combines the convenience of event emitter with multiple stores and you usually find yourself thinking much less about what changed the store causing my component to rerender much less often.

[1] https://effector.dev/