Cierre: el mapa completo, qué construir ahora y la pregunta final
El recorrido entero de los siete ideales a las migraciones visto de una sola vez, tres construcciones que consolidan lo aprendido y la única pregunta que conviene hacerle a cualquier arquitectura nueva.
Cincuenta y ocho niveles después, conviene detenerse a mirar el terreno desde arriba una última vez. Lo que empezó con un artículo de 2019 que diagnosticaba un compromiso mal aceptado por la industria termina en un conjunto de técnicas maduras, un puñado de problemas abiertos con nombre propio y, sobre todo, una forma distinta de mirar cualquier sistema. Esa forma de mirar es lo único que de verdad se lleva uno de un recorrido largo: los detalles se olvidan y se vuelven a consultar, pero el conjunto de preguntas que uno aprende a hacer se queda. Esta última lección hace tres cosas: pone el mapa completo en una vista, propone tres construcciones concretas para que lo aprendido no se evapore, y deja una sola pregunta que sigue funcionando cuando todas las herramientas de este track hayan sido sustituidas por otras.
- Reconstruir el arco completo del track en sus cinco movimientos y explicar por qué van en ese orden.
- Elegir una de tres construcciones que consolide de forma verificable lo aprendido.
- Formular la pregunta única que evalúa cualquier arquitectura nueva de este campo.
- Aplicar esa pregunta a un sistema que no sea local-first y comprobar que sigue siendo útil.
- Salir del track con un criterio propio y con la capacidad de defenderlo por escrito.
El territorio recorrido, de una sola vista
El track tiene cinco movimientos y ninguno es prescindible, porque cada uno responde a una pregunta que el anterior abrió.
El primero son los principios, del nivel uno al cinco: los siete ideales, la distinción entre local-first y offline-first, el coste real de la arquitectura cliente-servidor, la propiedad del dato y, sobre todo, el criterio inverso de cuándo no hacerlo, que es el nivel más maduro de ese bloque. El segundo es la máquina, del seis al diecinueve: todo lo que el navegador ofrece para guardar datos, de los cinco megabytes de localStorage a SQLite compilado a WebAssembly sobre el sistema de ficheros del origen, con las cuotas, el desalojo, los hilos, los bloqueos y la elección de líder entre pestañas. Ese bloque es el que responde si esto es posible.
El tercero es la convergencia, del veinte al cuarenta y cuatro, y es el corazón del recorrido: por qué sincronizar es difícil, por qué el tiempo del sistema no sirve para ordenar eventos, qué es exactamente un conflicto, el teorema que sostiene los tipos replicados, la familia entera de contadores, conjuntos, registros, mapas y secuencias, el fallo de intercalación que nadie vio durante décadas, las implementaciones que uno escribe a mano para entenderlas, las bibliotecas reales y el problema del historial que no deja de crecer. El cuarto es el sustrato, del cuarenta y cinco al cincuenta y tres: el hash como identidad, los grafos de Merkle, Git leído como almacén direccionado por contenido, la reconciliación eficiente, los transportes entre iguales y el mapa de los motores de sincronización. Y el quinto es la frontera, del cincuenta y cuatro al cincuenta y siete: identidad sin servidor, cifrado extremo a extremo sobre datos que convergen, migración de esquema y casos de estudio de quienes ya lo hacen en producción.
flowchart TD P[1 a 5 Principios] --> M[6 a 19 La maquina] M --> C[20 a 44 La convergencia] C --> S[45 a 53 El sustrato] S --> F[54 a 57 La frontera] F --> D[58 Sintesis] P --> D style D fill:#a6e3a1,color:#11111b style C fill:#89b4fa,color:#11111b
Los principios van primero porque deciden si hay que seguir leyendo. La máquina va antes que la convergencia porque durante años la respuesta a si esto era viable dependía del cliente y no del algoritmo. La convergencia ocupa el centro y la mitad del recorrido porque es la única parte que no se puede aprender por encima. El sustrato viene después porque solo tiene sentido cuando ya sabes qué estás moviendo por la red. Y la frontera va al final porque son los problemas que solo aparecen cuando todo lo anterior funciona.
Tres construcciones que consolidan el track
Leer no basta y este campo lo castiga más que otros, porque sus errores no se manifiestan en el desarrollo sino meses después y con dos dispositivos de por medio. Estas tres construcciones están ordenadas por esfuerzo y cada una fija una parte distinta de lo aprendido.
La primera es un editor de notas para una sola persona con varios dispositivos. Suena modesto y no lo es: obliga a montar el almacén local en un worker, a decidir la unidad de sincronización, a elegir motor de convergencia, a implementar el arranque en frío y a enfrentarse al primer conflicto real cuando editas la misma nota en el móvil y en el portátil sin red. Es el proyecto que más aprendizaje entrega por hora invertida.
La segunda es reimplementar un tipo replicado desde cero con sus pruebas basadas en propiedades, sin mirar la biblioteca que ya lo hace. Una secuencia es el ejercicio completo, pero un conjunto con lápidas ya obliga a razonar sobre concurrencia real. Lo valioso no es el código, que nunca usarás: es que al generar historias concurrentes aleatorias y comprobar convergencia descubres a mano las propiedades que hasta entonces eran una frase de una lección.
La tercera, la más ambiciosa y la que separa a quien ha entendido el track de quien lo ha leído, es un producto pequeño con dos regímenes conviviendo: un puñado de entidades con autoridad central y transacciones clásicas, y el resto del modelo replicado y convergente, con la frontera entre ambos documentada y defendida. Casi nadie construye esto en un ejercicio y es exactamente lo que un producto real necesita.
Notas multidispositivo
Fija el bloque de la máquina y el primer conflicto real. Es el proyecto con mejor relación entre esfuerzo y aprendizaje.
Un CRDT desde cero
Fija el bloque de la convergencia. Las pruebas basadas en propiedades enseñan más que cualquier explicación del teorema.
Los dos regímenes
Fija el criterio entero. Autoridad central para lo que la exige, convergencia para el resto, y la frontera escrita.
Un registro de decisión
Acompaña a cualquiera de las tres. Una página con las ramas descartadas y su evidencia vale más que el código.
La pregunta con la que conviene quedarse
Todo lo anterior caduca. Las bibliotecas se sustituyen, los formatos cambian, los motores que hoy están en su versión 1.0 tendrán sucesores, y una parte de los problemas abiertos tendrá respuestas parciales que hoy no se pueden anticipar. Lo que no caduca es una pregunta, y conviene enunciarla con precisión porque su formulación exacta es lo que la hace útil.
Qué fracción de este sistema necesita que alguien diga que sí, y qué se paga por esa fracción.
Es una sola pregunta con dos mitades y ninguna funciona sin la otra. La primera mitad obliga a inventariar, entidad por entidad, qué operaciones exigen un punto único capaz de aceptar o rechazar antes de que se consideren ocurridas, y la respuesta casi nunca es todo ni nada. La segunda mitad obliga a nombrar el precio de esa fracción en las cuatro monedas en las que se paga siempre: latencia, disponibilidad, privacidad y permanencia. Un equipo que responde las dos mitades por escrito ha hecho el trabajo de arquitectura; uno que responde solo la primera ha hecho un diagrama.
Lo interesante es que la pregunta no es específica de local-first ni deja de funcionar fuera de este campo. Aplicada a una arquitectura de microservicios, revela qué acoplamientos son necesarios y cuáles son heredados. Aplicada a un motor de sincronización comercial, revela dónde han puesto de verdad la autoridad por debajo del vocabulario de la página de inicio. Aplicada a un sistema con un servidor grande y sano, puede dar la respuesta perfectamente legítima de que casi todo necesita arbitraje y que el precio merece la pena. Esa también es una buena respuesta, y saber llegar a ella con argumentos es parte de lo que este track intentaba enseñar.
Cuando aparezca el próximo motor y su documentación prometa lo mejor de los dos mundos, no busques cómo empezar: busca dónde reside la copia autoritativa, qué ocurre exactamente con una escritura hecha sin red durante una semana, y qué se rompe si el servicio desaparece. Las tres respuestas están siempre en la documentación, casi nunca en la portada, y juntas sitúan la herramienta en el árbol de decisión en menos de veinte minutos.
Al final de un recorrido largo la tentación es medir lo aprendido en técnicas: sé implementar una secuencia replicada, sé montar SQLite en un worker, sé negociar una frontera de grafo entre dos réplicas. Todo eso es cierto y todo eso tiene fecha de caducidad, porque las técnicas de este campo se han sustituido dos veces desde que Ink and Switch publicó su artículo en 2019 y se volverán a sustituir. Lo que no caduca es haber entendido que una lista de propiedades políticas se deduce de una única decisión técnica. Que tu trabajo dependa de una relación comercial, que la velocidad de tu pensamiento dependa de una ruta de red, que tus datos vivan mientras viva una empresa, que alguien pueda revocarte el acceso a lo que escribiste: nada de eso es una consecuencia inevitable del software moderno, ni una cuestión de valores, ni un tema de conversación. Es lo que ocurre cuando la copia autoritativa del estado vive en el disco de otro, y deja de ocurrir cuando vive en el tuyo. Esa deducción, que el artículo de 2019 demostró y que este track ha desarrollado durante cincuenta y ocho niveles, es la aportación duradera del campo, y sigue siendo válida con cualquier biblioteca. De ella salen las cuatro ideas del primer nivel de esta síntesis, el árbol de decisión del segundo, los cinco problemas abiertos del tercero y el mapa del cuarto. Y de ella sale también la advertencia final, que conviene llevarse por delante de cualquier entusiasmo: local-first no es gratis, no es siempre correcto y no es una identidad profesional. Es una redistribución de la autoridad que se paga con complejidad trasladada a un sitio donde el problema está abierto, y esa transacción es excelente cuando el producto la justifica y ruinosa cuando no. La madurez que este recorrido intentaba dejar no consiste en elegir siempre local-first, sino en no volver a tomar esa decisión por omisión, que es exactamente lo que la industria llevaba veinte años haciendo. Quien sale de aquí sabiendo preguntar qué fracción de un sistema necesita que alguien diga que sí, y qué se paga por ella, ya no puede diseñar como diseñaba antes, aunque acabe eligiendo un servidor. Ese cambio es el único resultado del track que no se puede revertir.
- Reconstruye los cinco movimientos del track de memoria y nombra la pregunta que abre cada uno.
- Elige una de las tres construcciones, ponle una fecha concreta y escribe el registro de decisión antes del código.
- Aplica la pregunta final a un sistema que uses a diario y que no tenga nada que ver con este campo.
- Aplica la pregunta final a la última herramienta que hayas leído en un anuncio y sitúala en el árbol.
- Escribe en un folio, sin consultar nada, el argumento por el que un producto concreto no debería ser local-first.
- Guarda ese folio y vuelve a leerlo cuando termines la construcción que elegiste en el punto dos.