Overreacted

Hooks are great for simple use cases like `useState`, `useContext`, some uses of `useRef`, etc. and can make the code easier to read and reason about (while conveniently working very well with TypeScript). The rules do start to get really tricky though with complex use cases of `useEffect` and multiple levels of nested hooks, and implementation problems are often not easy to spot or debug. Dan Abramov has written a lot about the philosophy of hooks[0] at his site overreacted[1], I'd love to see a 'retrospective' write-up from him or another React team member about what they think the success and failures of hooks have been so far and if there are any changes planned for the future! [0]: https://overreacted.io/why-isnt-x-a-hook/, https://overreacted.io/algebraic-effects-for-the-rest-of-us/, https://overreacted.io/a-complete-guide-to-useeffect/ [1]: https://overreacted.io/

I highly recommend this talk (first half) for a great introduction of how React Hooks work internally, Ryan remakes the basics of hooks from scratch in 30 min: https://www.youtube.com/watch?v=1jWS7cCuUXw I agree on 2 of the points of Jared Palmer but disagree on one: - [agreed] The new "Concurrent Mode" will take things to a new order of complexity. I am actually very afraid of this, it seems like one of the things that might actually kill React, and I love working with React. I like it so much that I've invested into creating few React libraries to make my life easier. - [agreed] React Hooks are difficult to get started with and to really understand them. IMHO this is mainly due to "React lifecycle", which is just a difficult concept (even with classes!). Life is not easy, and there are some times that there's complexity and you need to learn new complex concepts. No issue here IMHO. - [disagree] React Hooks is currently magic. While it's a complex piece of software with many small details, once you understand fairly well the lifecycle (and React docs are great at this, and Dan Abramov's https://overreacted.io/ digs a lot deeper for the curious) all bugs are very clear. I am currently mentoring someone in React who already knew HTML+CSS+JS, my recommendations are: get used to the syntax by practicing, learn the 3-4 typical libraries, and learn very well the lifecycle including how useState's setState and useEffect's dependencies work. That's most of day-to-day React…

Shameless plug, but if this got you interested, I have a couple of longreads on the topic: - https://overreacted.io/a-social-filesystem/ - https://overreacted.io/there-are-no-instances-in-atproto/ From the official site, I'd also recommend https://atproto.com/articles/atproto-ethos

I love your posts! The Social Filesystem is amazing! https://overreacted.io/a-social-filesystem/

We need algebraic effects in more languages, this solves the function coloring problem. OCaml 5 has them and it seems to be doing quite well, combine that with the semantics of the borrow checker in the form of OxCaml and we might just have an ideal language. I'd like to see algebraic effects in Rust as well but sadly it seems their keyword generics initiative is languishing. Related, one of the former React maintainers wrote a primer on algebraic effects that's a good read: https://overreacted.io/algebraic-effects-for-the-rest-of-us/

Like I said above and in the post: it was an attempt to generalize the data fetching patterns developed inside of Meta and make them available to all React devs. If you watch the various talks and articles done by the React team for the last 8 years, the general themes are around trying to improve page loading and data fetching experience. Former React team member Dan Abramov did a whole series of posts earlier this year with differently-focused explanations of how to grok RSCs: "customizable Backend for Frontend", "avoiding unnecessary roundtrips", etc: - https://overreacted.io Conceptually, the one-liner Dan came up with that I liked is "extending React's component model to the server". It's still parent components passing props to child components, "just" spread across multiple computers.

This article about the AT protocol (which Bluesky uses) provides a good argument for why alternative social media sites like will help prevent this feeling of lock-in in the future and is worth a read: https://overreacted.io/open-social/

This is a short read - https://overreacted.io/goodbye-clean-code/ But it captures it perfectly, a large number of engineers go from jr to intermediate with their new found tricks. Except they cling to these tricks like it’s law, they have upskilled in one direction while sacrificing the open minded pragmatism for dogmatism. They’ll argue with you about these things, it’s in a book how can you not adhere to it!!? If you can onboard these lessons and still recognise the spots where it’s begging for some best practice but you should break the rule this time, then congrats you’re ahead of the curve, it takes most engineers a frustratingly long time to get pragmatic. If I had a penny for every awful DRY abstraction that became impossible to reason about, I’d have retired.

He's a React maintainer. He has a blog and a Twitter account which gained him quite some fame in the JavaScript world. https://overreacted.io/

I love this post for this exact reason: https://overreacted.io/things-i-dont-know-as-of-2018/ It's written by Dan Abramov who has been instrumental in React's development

> The class syntax garden path is much nicer than the weed-filled hedge maze it mostly replaced. I agree. Honestly I don't understand the obsession some people in the JS world have against classes. React components with state made more sense with classes than hooks. And yeah some people argue hooks are composable yada yada but if you need a React expert to write a useInterval hook to use a fundamental language feature, then maybe the model is not a great idea to begin with. https://overreacted.io/making-setinterval-declarative-with-react-hooks… Of course I know I'm in the minority here.

The class version is the most straight forward by a wide margin compared to either React function components or Solid functions. Dan Abramov wrote a great explanation a few years ago about an important difference between classes and functions for components, and a particular feature of classes that makes it harder to work with them at scale - prop capturing. https://overreacted.io/how-are-function-components-different-from-clas… It's worth reading if you think classes are more straightforward.

A great counter point to the thinking in this article is this snippet by Dan Abramov: https://overreacted.io/what-are-the-react-team-principles/#absorb-the-… Yes we need better tools as library authors but absorbing this complexity is our job. The more we take advantage of what Typescript can do the fewer types the end users deal with and the better experience they have. Making your library's internals simple should be a non-goal. The number of people dealing with it will be a fraction of the people dealing with codebases using your library.

The blog is sooo good! I enjoyed every single paragraph when reading it. If you're confused about the last part where it mentioned where useMemo and useCallback can help when passing props, I completely understand after reading Kent C Dodds block and Dan Abramov. Further, I learned a lot by taking interactive course from Dan Abramov in https://justjavascript.com Highly recommended! good read!! https://kentcdodds.com/blog/usememo-and-usecallback https://overreacted.io/a-complete-guide-to-useeffect/

Thanks for your work! Reading the article, seems like the main debate is on whether this should be included in pip. Fwiw, as a user experience, including it seems best. I think the experience npm (tries to) provide is a fine goal. However, whether it's a priority for pip and burdening maintainers is another matter. In any case, I'm more concerned with not repeating npm audit's mistakes. Abramov's blog post linked in the article [1] popped to my mind right away. Can you say any more about how pip-audit won't "cry wolf"? Especially since Python doesn't have great packaging standardization around tools, dev-dependencies, build dependencies, pip-tools vs pipenv vs poetry, etc. [1] https://overreacted.io/npm-audit-broken-by-design/

One article advocating against unnecessary abstractions that I really appreciate and highly recommend is Dan Abramov's: https://overreacted.io/goodbye-clean-code/

For anyone who wants a thorough understanding of how to think about React hooks in the context of things like setInterval, Dan Abramov wrote a great piece breaking it down in detail several years ago: https://overreacted.io/making-setinterval-declarative-with-react-hooks… This post helped hooks "click" for me, and once it did, I've absolutely loved them and now thoroughly enjoy writing custom hooks that greatly simplify my code.

I strongly recommend everyone to read A Complete Guide to use Effect[0] blog post by Dan Abramov. He 3 years ago addressed this exact problem and how useEffect solves it. [0] https://overreacted.io/a-complete-guide-to-useeffect/

Since others are reflecting on the merits of the article in ways I agree with, here's some articles I've collected from recent discussions on "clean code". Some even try to ditch the term or argue against it, others give context to the meaning. Would love to see others if anyone has any! https://bitfieldconsulting.com/golang/crisp-code https://overreacted.io/goodbye-clean-code/ https://www.cyclic.sh/posts/write-shitty-code https://qntm.org/clean

Dan goes into the topic of algebraic effects in this excellent blogpost: https://overreacted.io/algebraic-effects-for-the-rest-of-us/

They also eliminate subtle bugs that can emerge from `this` being mutable in classes, and they make the React lifecycle more intuitive. Rather than thinking about whether the component did mount, will mount or will unmount, you just associate side effects with certain states. Dan Abramov has a nice write up on the pitfalls of mutable this: https://overreacted.io/how-are-function-components-different-from-clas… With all that said, I would still say I'm not really a fan of hooks. I more see them as a necessary evil than a great feature. I try to use them as minimally as possible.

The last time [0] Effects were discussed, these recommendations were made [1],[2]. [0] https://news.ycombinator.com/item?id=28838099 [1] https://www.youtube.com/watch?v=hrBq8R_kxI0 [2] https://overreacted.io/algebraic-effects-for-the-rest-of-us/

It would be in your best interest to at least _learn_ hooks, since they are gaining popularity and are the presumed future of React [0]: > In the longer term, we expect Hooks to be the primary way people write React components. I also recommend learning the differences between function components (the prerequisite of hooks) and class-based components. This way you can gain understanding into why one would want to use one over the other which will ultimately serve you better than simply learning something just for the sake of learning it. "How Are Function Components Different from Classes?" [1] by Dan Abramov is a great start. [0] https://reactjs.org/docs/hooks-faq.html#should-i-use-hooks-classes-or-… [1] https://overreacted.io/how-are-function-components-different-from-clas… Edit: formatting (every time...)

I've normally heeded to the advice from Dan Abramov (https://overreacted.io/before-you-memo/) and KCD (https://kentcdodds.com/blog/usememo-and-usecallback): mainly due to the fact that I figured performance would take a significant hit by using unnecessary React.memo / useMemo calls throughout the codebase. One negative side-effect I could see as a result of this pattern is devs becoming too reliant on these optimizations and neglecting composition. But I suppose if the performance gain is substantial enough and DX isn't negatively impacted too much, it could serve as worthwhile-- especially at the level of scale which Coinbase requires.

It isn’t perfect but this is probably the best explanation that I know of https://overreacted.io/a-complete-guide-to-useeffect/

Dan Abramov has an interesting take on npm audit (https://overreacted.io/npm-audit-broken-by-design). Scanning through the vulns on GitHub Advisory Database, it looks like it still contains many that DA brought up as unhelpful at best (e.g. “Regular Expression Denial of Service”).

Yepp. It took me a long time to embrace the mindset that repeating things is sometimes way more elegant than unreadable abstractions. Dan Abramov's article [1] brilliantly put into words how I feel about DRY. It's a great heuristic, but still a heuristic. https://overreacted.io/goodbye-clean-code/

I like hooks and prefer them over class components, but I think this is a problem. Almost every React developer I know has a poor understanding of how hooks work because it's so fundamentally different from what they're used to. In most simple cases (probably 90+% of the time) you can get away with a flawed understanding of hooks; it doesn't typically bite you until you get into trying to write custom hooks with complex logic and/or side effects. Dan Abramov's dissertation on useEffect is a great example of how much complexity is hidden behind what appears at first glance to be a simple function: https://overreacted.io/a-complete-guide-to-useeffect/

I would instead of hosting comments on the site itself offload comments to Twitter/HN and link to it from the article like https://overreacted.io

The issue is it's not as simple as calling `setTimeout` as soon as your use case becomes more complex. See this great post from Dan Abramov about using setInterval with hooks: https://overreacted.io/making-setinterval-declarative-with-react-hooks…