React is holding me hostage

I'm not sure I'd ever expect a framework, React or anything else, to stop that behavior. If a child component signals to a parent that the state has changed then I would always expect that to cascade down the node tree. That could cause further updates. And more renders. That behavior is on me. If the framework decided not to cascade some updates that would be weird.

I think this highlights part of the problem with React and most other frameworks - people expect too much from them. If you're delegating all of your coding skill to the framework and expecting it to just magically work no matter what dodgy code design you throw at it then you're going to build a shitty app. You have to remember that you still have to think things through, use your skills as a dev, understand what's happening and why. That is always going to be true. You're always going to have to put the work in.

At the beginning of the article the author says they feel trapped by React because their previous, current, and next jobs are all going to be React based. That isn't true if they choose to put effort into learning other technologies and seeking roles that use them. If you work hard you find options open to you. Heck, they could move out of web and start writing completely different code that isn't even JS if they felt they wanted to. No one is being held hostage by React. You are only held hostage by your own fear of doing something hard. Feeling like you have to stick with React is a state of mind - you can change that with enough effort.

It's like you're speaking a different language to me, and I find that so weird considering we're using the exact same framework. How am I not having any of these issues?

I'm honestly at the point where I wonder if y'all are making things harder on yourself somehow, because I could see how getting obsessed with counting every single re-render and trying to overoptimize would result in the stuff you're saying while not actually impacting perf in a meaningful way.

My own impression is that the core model of state and rerendering is actually quite nice and intuitive, though often explained a bit wrong. The part that makes it complex and confusing are things like callbacks, which can trigger lots of unnecessary rerendering and force quite some boilerplate if you want to avoid that. If you can remove all the stuff around trying to avoid rerendering unnecessarily, React would be a lot simpler.

I also think that people are too quick to use the wrong tools for managing state in React, e.g. Context to avoid a bit of prop drilling.

We can agree that state management is complex, no matter how it’s done. If you disagree, cool go build a database.

Of all the complexities around state management, the one squarely placed at the top for me is: time.

State is a variable you care about, that will change over time.

Signals and Hooks/Effects present two very different approaches to the problem.

They both require updating your mental model, and they both have specialised tooling.

Myself, I’ve never fully grokked observables/signals—particularly in relation to a UI. They shift complexity into a location that I think makes them harder to reason about.

I did take to the React approach with Components and hooks. And in my experience so did many others.

I disagree with the article saying all frameworks must have signals, and I appreciate the React core team holding their ground on that.

It’s healthy for the ecosystem to have frameworks built on different ideas, otherwise why build a new framework?

But React, if you added signals I think you would warp it’s entire foundational paradigm.