▲ 110 points
back
112 comments
React is easy, once you understand why
{} !== {}
and that it uses reference equality as a proxy for value equality.
This is why the absolute simplest thing to do is to just memoize all the things (see https://attardi.org/why-we-memo-all-the-things/ for a deeper dive into this approach).
I know that the conventional wisdom (e.g. https://kentcdodds.com/blog/usememo-and-usecallback) is not to do that, but it's worth noting that Kent doesn't actually bring receipts for his claims, and also the discussion is typically limited to toy examples, not huge applications that have the potential for huge cascading renders when anything changes. In my own profiling of real world applications I have found that memoizing everything is not actually a performance regression. And then also consider the React Compiler, which of course does the same, at an even more fine-grained level than any human could be bothered to consistently do by hand.
I think we lack the primitives to understand and discuss messy complicated real world frontends. Something about UI state and its coupling to servers, plus time, plus Conway's Law, causes a real messy situation that appears to be much easier to avoid on the backend than on the frontend.
This creates a massive gulf between beautiful simple frontend toy examples and the reality of applications made with those same frameworks when deployed for multiple years and product cycles. I think it is a big part of what fuels shiny framework adoption. You think: "yes, this here is what will resolve the complexity and pains I see in my work codebase", and this is bolstered by your carefully curated personal side projects.
Why doesn't react switch to doing a more sensible equality check, rather than relying on JS's unfortunate choices? (E.g. value equality for arrays and objects) I feel like this would simplify most existing sensible code.
What about the terrible boilerplate and readability issues it causes?
I'm not in frontend mainly, but this article, and another short I watched about how useEffect is almost always wrong makes me feel uneasy about React. It's insidiously complex.
A bunch of `useCallbacks` are rendered ineffective because the top of the chain wasn't properly computed. And the fix isn't `useCallback`, its to rearchitect the tree. This feels wrong - either the API, the framework, or the language isn't powerful enough to ensure that someone does the right and performant thing. It seems like the new React Compiler tries to fix this - but I'm surprised React Compiler is a thing that needs to be built.
Yes, but in all fairness that’s React 16.8+ (2019)
Before that you could write:
class Page extends React.Component {
componentWillReceiveProps(nextProps) {
if (nextProps.url !== this.props.url)
logVisit(nextProps.url, this.state.nItems)
}
}
const Page = ({ url }) => {
const onVisit = useEffectEvent(visitedUrl => {
logVisit(visitedUrl, nItems)
})
useEffect(() => {
onVisit(url)
}, [url])
}It's a huge mess in the real world. Without good understanding and discipline, I've seen components which react profiler says re-render 15 times on an initial load because of cascading useEffect hooks.
I lack the expertise to be able to go in and rip it all out, and while I can share articles like this and others such as "You might not need useEffect", there isn't a really obvious way to deal with it all, especially if there are places which genuinely could do with proper memoisation.
> This feels wrong - either the API, the framework, or the language isn't powerful enough to ensure that someone does the right and performant thing.
It's the language. React uses a bunch of magic methods and requires you to follow rules about when to call them, with limited guardrails, because if you try to make developers do this properly (with higher-kinded types and monads) they throw their toys out of the pram. Our culture prefers "there are a bunch of subtle rules you have to follow and if you break them you'll get weird bugs or performance issues" to "there are a bunch of explicit rules you have to follow and if you break them your code won't compile", sadly.
I do frontend and I also feel uneasy about react. I stand by my assertion that it's trying to solve a hard problem and thus might actually require complex code, but still, the way react structures things with `useFoo` feels like they've really missed some easier ways to do it.
The trick is to not worry about useMemo and useCallback because it's rarely an issue unless you have 800 line components or don't compose but rather treat everything as if it was inheritance.
I've got pretty sizeable codebases, less than 5 useEffects ever (nowadays I only have one for a single location where I need to manually poll, the rest is useSyncExternalStore) and I only do useMemo for tables.
Compiler is just an additional performance improvement that's "free" and at least the compiler doesn't make it harder to understand how your code executes because it just works
I had do frontend for decades and witness the Jquery => Angular.js => React/Vue (Class) => React/Vue (Hook) transition.
And out of them, the react hook is the only one that 'doing it wrong' is easier. A good API interface should have least resistance for the user when doing things correctly. But React Hook almost feels like the complete opposite of this phenomenon. It's complex, comes with tons of foot gun. And yet still get popular?
Wondering if there is something other like this exists in the computer history.
React is the Git of UIs, the Vulkan, or whatever example you feel more apt for its ways of working, and changes across versions.
Unfortunely, it has won the mindshare game, in many SaaS products I tend to work on, they only provide React and by extension Next.js based SDKs, if I want to use vanila.js, Angular, Vue or whatever, it is on me to make it work, if it is possible at all, given the product expectations on its extension points.
Eventually the "everything must be React" wave is going to pass, hopefully.
The issues with useEffect come from a misunderstanding of how data is meant to flow in react, the fundamental concept on which the whole thing is based.
It’s not complicated at all.
> Adding non-primitive props you get passed into your component to internal dependency arrays is rarely right, because this component has no control over the referential stability of those props.
I think this is wrong? If you memoize a callback with useCallback and that callback uses something from props without putting it in the dependency array, and then the props change & the callback runs, the callback will use the original/stale value from the props and that's almost certainly a bug.
They might be trying to say you just shouldn't use useCallback in that situation, but at best it's very confusingly written there because it sure sounds like it's saying using useCallback but omitting a dependency is acceptable.
IMHO useCallback is still a good idea in those situations presuming you care about the potential needless re-renders (which for a lot of smaller apps probably aren't really a perf issue, so maybe you don't). If component A renders component B and does not memoize its own callback that it passes to B as a prop, that is A's problem, not B's. Memoization is easy to get wrong by forgetting to memoize one spot which cascades downwards like the screenshots example, but that doesn't mean memoization is never helpful or components shouldn't do their best to optimize for performance.
In my experience you're correct yeah - 95% of the time if you use it it should be included in the dependency array, and any edge cases where that's not true you should endeavour to understand and document. There's a 'react-hooks/exhaustive-deps' eslint rule for exactly this purpose.
author here , sorry for the confusion. I did not mean to imply that leaving out the prop from useCallback is better - you _always_ have to adhere to the exhaustive-deps lint rule to avoid stale closures (I have a separate blog post on this topic).
What I meant is that the API design of B, where the hook only works as intended if the consumer A memoizes the input props, is not ideal because A has no way of knowing that they have to memoize it unless they look at the implementation or it’s clearly documented (which it rarely is). It’s not A’s problem because B could’ve used the latest ref pattern (or, in the future, useEffectEvent) to work without passing that burden onto its consumers.
> > Adding non-primitive props you get passed into your component to internal dependency arrays is rarely right, because this component has no control over the referential stability of those props.
> I think this is wrong? If you memoize a callback with useCallback and that callback uses something from props without putting it in the dependency array, and then the props change & the callback runs, the callback will use the original/stale value from the props and that's almost certainly a bug.
The problem is up a level in the tree, not in the component being defined. See the following code block, where they show how the OhNo component is used - the prop is always different.
Ahh, this is such a pet peeve of mine. I hate how it leaks. A thing I often also encounter in this vein is when you write a useEffect, but the linter forces you to declare everything in the dependency array. I only want the effect to trigger when x changes, and then call function y. But I have to declare y as well, but then if y isn't memoed it will trigger every render. But I don't want that, and I might not even have full control of function y, coming from somewhere else. I could usecallback around it myself first, but that just moves the problem, as I need to maintain the correct closure, or there will be subtle bugs.
A second but unrelated grief with hooks is when you get async updates happening in between renderers where you want to update some state and then do some logic. Let's say I'm waiting for 2 requests to finish. They both should update a value in my state. However, to not lose an update if both happens at the same time, I need to do the setState with a callback to see the latest value. But then, what if I want to trigger something when that new calculated state value is z? I can't do that imperatively inside the callback, and outside it I can't see the new value and don't know that I now should do something additional. I have to do it in a useEffect, but that decouples it too much, the logic belongs where I want to put it, in my state hook. Not in some useeffect wherever. The other option is to misuse refs to also maintain a current state there in addition to the useState. So always use the ref, but set the state in the end to trigger a re render.
Hooks are so unelegant for real problems. I hate how they force your hand to write spaghetti.
I might be an outlier here, but I really miss declaring component properties as actual object properties.
Components seem extremely similar to classic OO, why can't I use the same syntax.
> Ahh, this is such a pet peeve of mine. I hate how it leaks. A thing I often also encounter in this vein is when you write a useEffect, but the linter forces you to declare everything in the dependency array. I only want the effect to trigger when x changes, and then call function y. But I have to declare y as well, but then if y isn't memoed it will trigger every render. But I don't want that, and I might not even have full control of function y, coming from somewhere else. I could usecallback around it myself first, but that just moves the problem, as I need to maintain the correct closure, or there will be subtle bugs.
If y never changes it should be declared as a const function outside of the context of the component, then it can be safely included in the dependency array without triggering unnecessary rerenders.
If y does change, you've just created a bug where your component will keep using an old version of y.
I use useEffect the same way and suffer the same grievances. I think it's because useEffect is intended as a way to keep references/state synced, not trigger downstream logic on various interactions. But there's only one useEffect, so it does all the things.
> The other option is to misuse refs to also maintain a current state there in addition to the useState. So always use the ref, but set the state in the end to trigger a re render.
Arugably this isn't a misuse, but just accepting that Reacts state management isn't powerful enough for what you need. Something akin to useRef + useSyncExternalStore is often what developers want.
For example, there's no guarantee that your useEffect will be invoked with the intermediate state you wanted to observe.
> I hope this example shows why I'm passionately against applying memoizations. In my experience, it breaks way too often. It's not worth it. And it adds so much overhead and complexity to all the code we have to read.
This design means that unlike vanilla JS, web components, Vue, Svelte, Solid, etc. where your state explicitly opts in to state changes, React requires component code to explicitly opt out of state changes (making the model much harder to wrap your head around and harder to do well).
This is the actual root cause of all of the underlying complexity of React. In signals-based frameworks/libraries and in vanilla JS with callbacks, there is rarely a need to explicitly memoize.
For the curious, I have some code samples here that make it more obvious: https://chrlschn.dev/blog/2025/01/the-inverted-reactivity-mo...
React is astonishingly clever, the kind of use of functional ideas that is talked about in On Lisp [1] Comparing it to many systems like Microsoft's WPF or Oracle's JavaFX it's an amazingly simple way to implement components. On the happy path life is easy, but go off that path and you're in trouble. Visicalc had real reactive programming in 1979, all that useX stuff is a way to fake it without needing a compiler -- which systems like Vue 5 and Svelte need.
Sometimes I think it would be fun to make an immediate mode rendering framework similar to React -- and given that it can take 10x or more refreshes for a page to be done rendering, it might as well be immediate mode.
But yeah, I figured out the need for signals back in 2006 or so when I was working on a knowledge graph editor based on GWT and having to explain why there were "race conditions" depending on whether or not data was cached. When I got into modern JS around 2017 everything seemed worse than the frameworks I'd built for some very complex (think Figma) applications more than a decade ago.
[1] Of which 80% of the examples don't really need macros
Most of the time it’s not with memoising anything because as it’s pointed out it’s easy to create a component that tries to be performant but its consumer breaks it because it passes a non memoized prop. And it is weird that a library that pushes for composability of UI components demands of you to think of such edge cases.
I have been writing react professionally in large codebases for 5 years now and I am quite disappointed by the course react followed. It became more complex but not more powerful, it introduced features that feel like bandaid fixes rather than new tools that open up new opportunities, it broke its own rules and patterns (the new “use”, the “useForm”) and it aggressively pushed for server side rendering, alienating hobbyists and small scale users who enjoyed SPAs.
Like another user mentioned, I am irritated by the linter rule for full exhaustive dependencies in effects, because it takes control away and also forces me to memoise everything. Or not, as the article points out. The library is not easy to build with anymore and it’s comfortably sitting at the point where it’s used everywhere and people are getting tired of its quirks. Which, if we are lucky, means it prepares the way for something better.
I would describe the reasons to useMemo or useCallback as follows, in order of decreasing importance: 1) referential equality of non-primitives (any object, function, etc.) passed downstream as props and 2) expensive computation. The first one is for me non-optional, and I’ll focus on that (as the second one is self-explanatory).
Once you know about the reactive render cycle, it becomes a second nature to never create any object other than via a memo function with declared dependencies. Anything else—any instance of something like <Component someProp={[1, 2, 3]} />—is, to me, just a bug on the caller side, not something to be accommodated.
Furthermore, ensuring referential equality has benefits beyond avoiding re-renders (which I would acknowledge should generally be harmless, although are in practice a source of hard to spot issues and loops on occasion).
— First, it serves as a clarity aid and documentation for yourself. It helps maintain a mental graph like “caller-provided props A and B are used to compute prop C for a downstream component”. Code organized this way tends to have self-evident refactor routes, and logic naturally localizes into cohesive sub-blocks with clearly defined inputs and outputs.
— Second, and it is obviously an ES runtime thing, but it is simply weird to have to reason about objects being essentially the same but different—and if memoization allows me to not have to do it and, with some discipline, make it safe to assume that (() => true) is the same as (() => true), why pass on that opportunity?
That said, now that I see an alternative take on this, I will make sure to document my approach in the development guidelines section of the README.
> it is obviously an ES runtime thing, but it is simply weird to have to reason about objects being essentially the same but different—and if memoization allows me to not have to do it and, with some discipline, make it safe to assume that (() => true) is the same as (() => true), why pass on that opportunity?
it sucks both ways - the default is that stuff is different if it looks the same so you can't not do anything, but the only solution is both a lot of work and really easy to mess up completely. The TC39 Composites proposal[1] would be a great step in the right direction, but it will take years in the best scenario, there's really no guarantee that React will take advantage of it, and it still leaves out a lot of cases (Dates, to name one)
yeah I completely agree, I think there's a whole logic of reasons to using useEffect/useCallback/useMemo that the post didn't acknowledge.
personally, I want to have a comprehensive understanding of exactly when and why each of my components re-renders, and to do that I use hooks and design around referential equality. like you said, it's a kind of documentation, more about organization than performance.
not to say that this way is intrinsically better! just that the style is appealing for its own reasons
People say "don't just blindly use React.memo, fix slow renders first." But like... with referential identity being so cheap, blindly applying React.memo should be a huge win?
CostPostCache = CostOfCache + CacheHitPercentage * CostWhenHittingCache + CacheMissPercentage * CostPreCache
CostOfCache is pretty cheap compared to the CostPreCache IMO... CostWhenHittingCache is very low... and CacheMissPercentage is also probably pretty low in your typical React component that has more than 2 children node involved. Mathematically it feels like a no-brainer!
"Fix your slow renders first" just feels off. Yes you want to fix slow first renders! You also want to avoid wasting render cycles. These are distinct issues from my view. What am I missing? Why shouldn't React "just" do useMemo by default?
> blindly applying React.memo should be a huge win
That’s what the react compiler does, and it’s a good idea in that case because the compiler knows how to do it correctly, for _everything_. When humans try to do it, they will likely get it wrong (see the real world example in the article, this is the norm imo).
Hooks turn out to be a leaky and contagious abstraction.
I still don't 100% understand why `React.memo` is not applied by default, wrapping every single component in a `memo` is crazy overhead and non-trivial to enforce codebase-wide.
Sure performance is a concern but is recursive re-rendering really cheaper than memoing all props?
Someone used to argument with me that "it will make render pass that use external value works if it always renders".
But I wonder should it even work at first place? It feels like you are covering the problem instead of actually fix it. Make broken things broken is a lot healthier for the code base in my opinion.
Immediately find out things to be broken is 100x better than find out it suddenly not works and can't even figure out why is it broken months later in my opinion.
Use external value in Vue is very noticeable in contrary to React. Because it will definitely not work even once. The in component computed or component itself both enforce memorize . Render will be skipped completely it you used external values there so the framework did not notice anything is changed.
that's the the react compiler is supposed to be able do, memoize when necessary
I think folks were too quick to throw out the good things about redux when hooks came out. Namely “dumb” presentational components that had no logic and abstractions for wiring up data and actions (mapStateToProps and mapDispatchToProps).
Sure reducers could be a bear (and asynchronous actions were hard), but the easily testable and portable logic-less views were really nice to work with.
Having worked in a number of codebases from React’s earliest days until now, I see echos of the bad old mixin days in the usage of hooks.
I'm the primary Redux maintainer. FWIW, `connect` still exists and we have no plans to remove it, but it's also _very_ complicated internally and we honestly don't want people using it today. If I _could_ remove it without breaking user apps I would. `useSelector` is a drastically simpler implementation, better app performance, and smaller bundle size.
I do get what you mean about the conceptual separation, although something about the HOC approach also led to a lot of historical user confusion about "where _are_ my props coming from?".
As for writing the rest of your Redux logic, our modern Redux Toolkit package has addressed the historical concerns about boilerplate and other pain points:
- https://redux.js.org/introduction/why-rtk-is-redux-today
- https://redux.js.org/tutorials/essentials/part-2-app-structu...
I've been toying with an idea of a pattern. I'm curious as to if it has a name. I'll write a blog post once I have an app using it. In the meantime, it's (roughly):
- No Hooks.
- Don't try to sync any state. E.g. keep a dom element as the source of truth but provide access to it globally, let's call this external state.
- Keep all other state in one (root) immutable global object.
- Make a tree of derived state coming from the root state and other globally available state. (These are like selectors and those computations should memoized similar to re-select)
- Now imagine at any point in time you have another tree; the dom tree. If you try to make the state tree match to dom tree you get prop drilling.
- Instead, flip the dom tree upside down and the leaves get their data out of the memoized global state.
- Parent components never pass props to children, the rendered children are passed as props to the parent.
One note, is that the tree is lazy as well as memoized, there's potentially many computations that don't actually need to be computed at all at any given time.
You need something like Rx to make an observable of the root state, some other tools to know when the external state changes. Some memoization library, and the react is left with just the dom diffing, but at that point you should swap out to a simpler alternative.
Have a look at Legend State, it lets you do something very close to this (leaves get their data out of the global state directly) with React.
you can do something like this with most global state libraries, Jotai to name one. But very soon you'll see that you need effects there, so you'll need that global state solution to be rock solid in that aspect
Whenever I see articles like that, I can't help but feel the migration from Class components to functional components with hooks was a big complexity jump for little gain.
I don't have a problem with needing to memoize props passed to child components for their memoization to work.
If your parent component doesn't need the optimization, you don't use it. If it does need it, your intention for using useMemo and useCallback us obvious. It doesn't make your code more confusing inherently.
The article paints it as this odd way of optimizing the component tree that creates an invisible link between the parent and child - but it's the way to prevent unnecessary renders, and for that reason I think it's pretty self-documenting. If I'm using useMemo and useCallback, it's because I am optimizing renders.
At worst it's unnecessary - which is the point of the article - but I suppose I don't care as much about having unnecessary calls to useMemo and useCallback and that's the crux of it. Even if it's not impacting my renders now, it could in the future, and I don't think it comes at much cost.
I don't think it's an egregious level of indirection either. You're moving your callbacks to the top of the same function where all of your state and props are already.
The useRef pattern seem like a code smell, maybe because I had some troubles with refs over the years.
Things were simpler when we had lifecycle methods to manage some of this things. But I`m sure that the next version of react will change everything and make us come up with more patters to try to fix the same problem again...
What do you mean you don't need 8 dependencies for one useEffect? How else will you update this string!
React needs a useful useLessCallback optimization, with an "off" switch and a hand for turning itself off, right out of the box.
Useless Machine:
https://en.wikipedia.org/wiki/Useless_machine
A useless machine or useless box is a device whose only function is to turn itself off. The best-known useless machines are those inspired by Marvin Minsky's design, in which the device's sole function is to switch itself off by operating its own "off" switch. Such machines were popularized commercially in the 1960s, sold as an amusing engineering hack, or as a joke.
More elaborate devices and some novelty toys, which have an obvious entertainment function, have been based on these simple useless machines.
History
The Italian artist Bruno Munari began building "useless machines" (macchine inutili) in the 1930s. He was a "third generation" Futurist and did not share the first generation's boundless enthusiasm for technology but sought to counter the threats of a world under machine rule by building machines that were artistic and unproductive.
A wooden "useless box"
The version of the useless machine that became famous in information theory (basically a box with a simple switch which, when turned "on", causes a hand or lever to appear from inside the box that switches the machine "off" before disappearing inside the box again) appears to have been invented by MIT professor and artificial intelligence pioneer Marvin Minsky, while he was a graduate student at Bell Labs in 1952. Minsky dubbed his invention the "ultimate machine", but this nomenclature did not catch on. The device has also been called the "Leave Me Alone Box".
Minsky's mentor at Bell Labs, information theory pioneer Claude Shannon (who later became an MIT professor himself), made his own versions of the machine. He kept one on his desk, where science fiction author Arthur C. Clarke saw it. Clarke later wrote, "There is something unspeakably sinister about a machine that does nothing—absolutely nothing—except switch itself off", and he was fascinated by the concept.
Minsky also invented a "gravity machine" that would ring a bell if the gravitational constant were to change, a theoretical possibility that is not expected to occur in the foreseeable future.
useMemo and useCallback - LLMs do love including them! It drives me crazy removing them
I remember when React api was unique, then it comes up with some idea (hooks) and other front-end frameworks copied it, that's like confirmation that the idea is crap.
don’t even get me started on react strict mode. I’m looking at porting a couple of my personal apps to rails 8