rfcs VS react-tracked

Examples from the conversations of that time:

> ...we want closures to capture the values we rendered with, and to keep "seeing" those values forever. That's really important for concurrent mode where a notion of current value doesn't really exist. Hooks design models a component as being in many non-clashing states at the same time, instead of switching the "current" state (which is what classes model well). People don't really need to think about these details, but they're motivating the design a lot. [0]

> In Concurrent Mode, render may run more then one time, and since this in a class is mutable, renders that should be the same may not be. [1]

[0] - https://github.com/reactjs/rfcs/pull/68#issuecomment-4778866...

[1] - https://tkplaceholder.io/why-function-components-fit-react-b...

There are multiple names for this hook. You can find the documentation under the names useEvent or useEffectEvent.

-https://www.patterns.dev/ -https://github.com/reactjs/rfcs/blob/main/text/0188-server-components.md -https://dev.to/this-is-learning/qwik-the-post-modern-framework-3c5o -https://dev.to/this-is-learning/astro-framework-169m -https://developers.google.com/web/updates/2019/02/rendering-on-the-web -https://web.dev/vitals/

However, in React, function components can return a ReactNode. This type includes number | string | Iterable | undefined and will likely also include Promise( in the future.

I was also hoping that useEvent would eliminate some weird dependency cases, who knows when that will actually happen (https://github.com/reactjs/rfcs/pull/220).

Given a lot of unknowns on SSR and ReactEng working on RSC it feels like the wrong move to use next.js and I should just use normal react. For basic react is create react app the way to go or vite?

As mentioned before, Next.js takes a stance of treating every component as a Server Component by default. If you want to use a Client Component, you'll need to annotate the file with use client; directive at the top of the component file.

Use client is actually a React convention for what it’s worth. https://github.com/reactjs/rfcs/pull/227

Automatic render optimization is to do this automatically. Is this possible? It's possible with utilizing proxies. Proxies allow us to detect state property access. I have been working on this for years, and react-tracked is one of the resulting projects that use this technique. We have an internal library called proxy-compare.

While in a smaller application, excessive re-rendering may be unnoticeable or have no negative impact, as your application grows, each re-render may cause delays or lags in your UI. In this tutorial, we’ll use React Tracked, a library for state usage tracking, to optimize our application’s performance by preventing unnecessary re-renders.

The best, and perhaps only approach I have found so far is react-tracked. It does some internal tracking with proxies that I don't quite understand, but it actually works as advertised with a very minimal API.