Conclusión : qué te llevas del libro

Lo que (espero) te llevas de este libro

El autor estructura el cierre como una lista de principios que el libro defiende, no como un resumen temático.

Repensar best practices

React en 2013 fue una ruptura: introdujo JSX, el virtual DOM y unidireccional data flow. La historia no es React nació listo — es React obligó a la comunidad a repensar. La lección transferible: el status quo de hoy será el anti-patrón de mañana. Mantente escéptico de cualquier “best practice” que no entiendas hasta los cimientos.

Entender JSX de verdad

JSX no es HTML en JavaScript por pereza: es un ejemplo de cómo puedes extender cualquier lenguaje con un parser + transpilador. Si quieres, puedes hacer un DSL dentro de JS/TS, y Babel/swc ya te dan el pipeline gratis.

Las constraints son amigas

React nació de las restricciones del navegador (reflows por leer offsetWidth, eventos cross-browser, etc.). La regla se repite en cada nivel:

• Restricciones de la web → motivaron virtual DOM, unidirectional flow, SyntheticEvent.
• Restricciones de concurrencia → motivaron render lanes, useTransition, useDeferredValue.
• Restricciones de hidratación → motivaron RSC + module references.
• Restricciones de “todo en el bundle” → motivaron RSC, server actions, “use server”.

Las abstracciones declarativas desbloquean capabilities

Cuando React describe la UI como JSX, desacopla qué quiero pintar de cómo se pinta. Mismo árbol, distintos renderers: navegador, servidor, terminal, canvas, React Native, RSC… Es la misma jugada que hace el kernel Linux al abstraer el hardware.

Lo que (espero) te llevas de los frameworks

El libro defiende que todo framework React implementa los mismos tres features (SSR, routing, data fetching) con distintos nombres. Una vez que lo ves, las convenciones dejan de sentirse arbitrarias y entiendes qué trading hidden hay detrás de cada decisión.

Ship drastically less code

RSC es la iteración más reciente de la misma tesis de siempre: al cliente solo lo que necesita interactividad. El bundler ya no es “todas mis dependencias”; es “qué cambia tu UX”. Esa tendencia no va a invertirse.

La separación de JavaScript “puro” — React, frameworks y runtimes

El timeline que recorrimos

   Historia          →  por qué React, qué problemas resolvió
   JSX               →  cómo se compila, por qué no es HTML
   DOM virtual       →  React elements, diffing, rerenders innecesarios
   Reconciliación    →  Fiber, render phase, commit phase, double buffering
   Optimización      →  React.memo, useMemo, useCallback, lazy, Suspense, Forget
   Patrones          →  HOC, render props, compound components, state reducer
   SSR               →  renderToString, renderToPipeableStream, hidratación, resumability
   Concurrencia      →  scheduler, render lanes, useTransition, useDeferredValue, useSyncExternalStore
   Frameworks        →  Remix, Next.js, filesystem routing, loaders, server actions
   RSC               →  server components, "use server", wire format
   Alternativas      →  Vue, Angular, Svelte 5, Solid, Qwik, signals vs Forget

Las tres macrotendencias que el autor ve como dirección de la industria:

Cómo mantenerse al día

El autor es explícito: la velocidad del cambio es el reto, no la profundidad técnica. Cuatro hábitos que recomienda:

1. Seguir fuentes confiables

• Documentación oficial: react.dev.
• React core en X / Twitter: @sophiebits, @sebmarkbage, @acdlite, @rickhanlonii, @dan_abramov2, @zmofei.
• Comunidad creadora: @kentcdodds, @kadikraman, @Shaundai, @rachelnabors.

2. Unirse a comunidades

• Reddit: r/reactjs
• Discord: Reactiflux
• Newsletters: bytes.dev, This Week in React
• Podcasts: React Roundup

3. Asistir a conferencias (o ver los vídeos después)

• React Brussels
• React Alicante
• React India
• React Day Verona

4. Experimentar en proyectos pequeños

El autor lo resume en una línea: “Nada mejor que tocar el código”. Un fin de semana construyendo con Solid o Qwik te enseña más sobre los límites de React que tres meses leyendo sobre ellos.

5. Construir en público

Popularizado por Shawn Wang (@swyx). Compartir lo que aprendes — en Twitter, en un blog, en una charla interna de tu equipo — te fuerza a explicar, que es la mejor forma de entender. Escribir esta wiki del libro es exactamente ese ejercicio para mí; el libro es una disculpa por escribirlo, no por leerlo.

Cierre

Resumen en cinco frases

1. React empezó como librería, ganó el ecosistema siendo primero un modelo de componentes, segundo un protocolo de servidor (RSC).
2. El reconciler es Fiber: dos árboles, doble buffer, render phase interrumpible, commit phase síncrono.
3. La concurrencia introduce prioridades (lanes), useTransition para diferir y useSyncExternalStore para evitar tearing.
4. Los frameworks no son magia: resuelven SSR + routing + data fetching con distintas filosofías.
5. El futuro inmediato son RSC + server actions, y React Forget como respuesta a signals.

Eso es Fluent React. Ahora, a construir.

Próximos pasos

Has terminado la wiki. Si quieres extenderla:

• Añadir notas de caso de uso: xx-ejemplo-practico-rsc.md, xx-patrones-de-cache-en-nextjs.md, etc.
• Enlazar desde tu nota raíz de React 19 (la del react-basics/00-react.md) hacia [[00-fluent-react-tejas-kumar]].
• Marcar fuentes para profundizar: react.dev, overreacted.io (Dan Abramov), las charlas de Aiden Bai sobre partial hydration y signals.
• Volver a la práctica: levantar una mini-app con Next.js App Router + una server action y verificar empíricamente la diferencia en bundle size y TTFB.