Hacker News Reader

Comment by hu3 | Hacker News Reader

Humans have limited cognitive capacity (and time).

To me magic code is code that requires a significant level of cognitive investment to understand and keep in your brain RAM. That threshold varies between people but it's always there.

In React's case, the chosen solution is not the issue here. It's a symptom of bad architecture. The library should be doing more than rendering twice to protect developers from side effects, to a point that rendering twice wouldn't be required.

That feels as bad as rebooting JBOSS servers once a day to "fix" OOM crashes. It's a hack at best and doesn't fix the real issue.

View on HN

I disagree. React is saying that you need to pass it a function for rendering a component and it does not guarantee how many times that function will be called. There are documented, well defined ways to call side effects based on component lifecycles.

However, how can react know what a side effect is? Hook into well known ones by hijacking the browser API? That sounds like a bad idea. Provide their own linter/compiler. That seems on the radar but I'm not sure I like the idea.

Also react doesn't stop you from doing it. You can say nah it's fine I want my side effect. It just runs the render explicitly twice in development, something that could happen in production for various reasons, so you can see what will happen.

Your proposed solution isn't very practical. A better solution would be a guarantee that render will only run once. But that's not how react has ever worked. There are other frameworks that do that. As with anything, there'll be a trade-off.

> The library should be doing more than rendering twice to protect developers from side effects

Like what?

probably the parent poster does not use React so it would seem a heavy demand on a human to make, given the already stated limited cognitive energy and time.

I suppose I would think not rendering twice and some sort of warning about side effects would be beneficial, rendering twice means that you get a misleading view of what your application behavior is, I can see how people would - from an architectural perspective - consider it bad without necessarily using the framework.

> some sort of warning about side effects would be beneficial

Rendering twice is exactly what allows you to detect that. How would you detect a side effect if not by calling the function twice?

React's contract is that your component should be allowed to render twice without any changes so this is just upholding the invariant in dev mode.

You can use a language / compiler / static analyzer that restricts side-effects.

Funny you mention that https://react.dev/learn/react-compiler

I do also use React, unfortunately.

my mistake, I feel your pain.

Things like validating or limiting possible React code you can write such that these effects are impossible, in the same manner that abstract data types in programming languages attempt to define data structures that are correct by construction, or the same way that reactive programming enforces a programming paradigm that attempts to minimize unwanted interaction glitches.

If you have to ask.

Learn Elm and you'll see React's shortcomings clearer. They don't render twice but that is just the tip of the iceberg.

Be warned though, exiting the cave is painful.

I've used elm. It's not that great. In many ways it has the same shortcomings as react but far worse. That is you find yourself wanting to do something as yet unsupported (which we often do because otherwise why write new software in the first place) you have to break out of it's abstraction. Except doing so is 10x harder with elm, and the community around it is so much smaller you can't find the answers. Also, after I personally had moved on, there was something of a tension between the community and the authors. Maybe that's resolved, although I'd suspect for some the resolution was to no longer be part of it.

Reply on news.ycombinator.com