Lo que realmente entra primero en el modelo de código abierto es la cuestión de la cadena de suministro.

Una vez que un tema de este tipo esté escrito como “sellado”, se llamará la atención sobre una imagen demasiado dramática. Los cambios más comunes en el proyecto son menos dramáticos: la fuente de descarga pública se vuelve inestable, comienzan a aparecer sitios espejo, una determinada versión se retira de los estantes, el ritmo de las actualizaciones continuas se interrumpe y la cadena de razonamiento en manos del equipo de repente tiene que aferrarse a sí misma.

La capa de alojamiento toma la presión primero

Cuanto más se analiza el modelo de código abierto, más fácil es ver una cosa con claridad: lo que pueden verse directamente afectados por las políticas, los controles de exportación y las reglas de la plataforma a menudo no son los documentos ponderados que se han distribuido, sino el alojamiento público, la inferencia en línea, la distribución de versiones y las entradas predeterminadas.

Esto significa que, aunque parezca “sellado”, el camino que en realidad está cortado suele ser el más fácil. Lo que solía ser un proceso simple de abrir una URL, configurar una interfaz de alojamiento y llamarla una vez, de repente cambió a buscar una imagen, agregar una firma, verificar el hash, verificar la licencia y confirmar la versión revertida. Las acciones pueden parecer pequeñas, pero cuando se conectan, forman una cadena de suministro completa.

Una vez que se bifurca la versión, el nombre ya no explica el problema.

La parte más difícil del modelo de código abierto nunca es “si existe o no”. Una vez que el peso se extienda a múltiples imágenes, múltiples almacenes organizacionales y múltiples ramas de ajuste, diferentes comportamientos crecerán bajo el mismo nombre.

En este momento ya no basta con discutir “si el modelo sigue ahí”. La pregunta más problemática es: cuál es la línea principal, cuál es solo una imagen especular, cuál ha sido entrenada dos veces y cuál aún conserva el comportamiento de razonamiento original. El nombre todavía puede referirse al mismo proyecto, pero el resultado ha comenzado a divergir. En este punto, si el equipo todavía considera “el mismo nombre” como “lo mismo”, los resultados en línea se desviarán tarde o temprano.

Ésta es también la mayor diferencia entre los modelos de código abierto y las API de código cerrado. La API de código cerrado está desconectada y el rendimiento es muy sencillo; el modelo de código abierto está bifurcado y, en la superficie, el servicio todavía se está ejecutando, pero detrás de escena se han cambiado la versión, las dependencias y los límites de comportamiento. Lo que es realmente inquietante a menudo no es el fracaso, sino “todavía parece funcionar”.

Lo que realmente hay que arreglar es el origen, la reversión y la recurrencia fuera de línea.

Cuando se produce este tipo de cambio en el proyecto, lo primero que hay que compensar no son las emociones, sino tres cosas: origen, reversión y recurrencia fuera de línea.

La fuente debe ser rastreable hasta almacenes específicos, envíos específicos y documentos de peso específicos. La reversión debe poder volver a la versión anterior del comportamiento, no solo a un nombre. La reproducción sin conexión debe poder ejecutar la misma ronda de experimentos nuevamente cuando la red tiembla, se pierde el espejo o se elimina el paquete ascendente.

Muchos equipos suelen sentir que estas cosas están muy lejos de ellos. No es hasta que un día una actualización cambia el estilo de salida, o una determinada sincronización de imágenes es lenta, que descubren que el problema no está en la capacidad del modelo, sino en que la cadena de dependencia no se gestiona como un ciudadano de primera clase. Cuanto más abierto sea el modelo, más obvio será. Porque lo que aporta el código abierto no es una “entrada libre” siempre estable, sino una cadena de suministro cada vez más larga.

La parte más física no suele ser el cuerpo del modelo.

Cuando se trata de un entorno de producción, el lugar más probable para equivocarse no suele ser la ontología de peso, sino la entrada predeterminada, las actualizaciones automáticas y las dependencias implícitas.

Si un equipo considera un determinado portal en línea como la única fuente, aún puede llamarlo hoy, pero es posible que tenga que encontrar temporalmente un reemplazo mañana; si considera una estación espejo como la verdad predeterminada, la deriva de la versión se infiltrará silenciosamente en el entrenamiento y la evaluación; si el ritmo de actualización es demasiado estricto, la estabilidad del comportamiento actual no está clara y la nueva versión de mañana estará en línea.

Entonces, este tipo de problema parece política internacional, pero cuando se trata de ingeniería, se parece más a la gobernanza de la cadena de suministro. Quién controla la entrada, quién es responsable de firmar, quién define la reversión, quién guarda la versión anterior y quién puede reconstruir sin conexión, estos son los límites que seguirán afectando la entrega. Una vez que el modelo se haga público, el espacio dejado para las acciones externas será menor; El espacio que queda para que el equipo cree sus propias lecciones será mayor.

Si el modelo de código abierto estará “sellado” es una cuestión un poco estrecha. Un juicio más realista es: cuanto más abierto es el código, más difícil es controlarlo con una sola acción; pero cuanto más abierto es, más necesita administrar versiones, fuentes, reversiones y recurrencias fuera de línea. Si no se contiene esta cadena de suministro, cualquier fluctuación externa se amplificará hasta convertirse en un accidente que parece un “accidente modelo”.