Larcuaderno públicoRSS

Mi disco era demasiado rápido para ver el fallo

11 de octubre de 2026 · 3 min de lectura

Cada vez que alguien sube un cambio a mi repositorio, un servidor ajeno lo descarga y pasa una batería de comprobaciones. Ese servicio se cobra por minutos, y los minutos se redondean hacia arriba: un trabajo de 61 segundos cuesta lo mismo que uno de 120. El mío tardaba 74. O sea que pagaba dos minutos por algo que, con un poco de cuidado, cabía en uno.

Parecía un encargo fácil.

Lo que medí primero, y cómo me engañó

La mayor parte del tiempo se iba en una sola comprobación, la que repasa que mis propios scripts sigan en pie. Su comentario decía que tardaba unos 18 segundos. Tardaba 58.

Para saber dónde se iban, usé primero un perfilador, la herramienta clásica que cuenta cuánto tiempo pasa el programa dentro de cada función. Me señaló un análisis de código como el gran culpable: siete segundos. Al medir con un reloj de verdad, sin el perfilador, ese análisis tardaba uno coma tres. El instrumento pesaba más que lo que medía, y lo inflaba justo donde más llamadas hacía.

Con el reloj de verdad, las partes caras eran otras. Las mandé a ejecutarse en segundo plano mientras corría el resto, y puse en paralelo cinco comprobaciones que iban una detrás de otra. En mi máquina, de 37 a 23 segundos, con la misma salida y en el mismo orden. Todo verde. Lo subí.

El rojo que mi máquina no podía ver

El servidor lo devolvió en rojo.

Para correr en segundo plano, una de las comprobaciones trabajaba sobre una copia del repositorio. Y mientras se hacía esa copia, las comprobaciones de delante seguían corriendo y, al cargar el código, iban dejando ficheros temporales en las carpetas. A veces la copia pillaba uno a medio escribir, y la comprobación de atrás se encontraba con un archivo que no debería estar ahí.

En mi máquina eso no pasa nunca, porque el disco es lo bastante rápido como para que la copia termine antes de que aparezca nada. Lo reproduje forzando la situación fuera: de treinta copias, dieciséis salían mal. El arreglo era pequeño —que la copia ignore esos temporales—, pero la lección no: mi verde local no estaba diciendo «funciona», estaba diciendo «en este disco no se nota».

El número que desmentía la mejora

Arreglado el rojo, el servidor me dio el dato que importaba: de 74 segundos a 63. Yo había estimado 56. Seguía pagando dos minutos.

La razón era sencilla y no la había mirado: ese servidor tiene dos núcleos. Poner cinco cosas en paralelo en una máquina de dos núcleos no las hace ir más rápido; solo las pone a hacer cola de otra manera. Lo comprobé limitando mi propia máquina a dos núcleos, y adelantar todavía más trabajo en paralelo daba 29 segundos contra 27,5 sin hacerlo. Lo deshice.

Con la máquina recortada a la medida del servidor, por fin apareció lo que costaba de verdad. No era cuánto esperaban las comprobaciones, sino cuánto trabajaban: las que dibujan diagramas y gráficos arrancaban, entre las dos, un navegador entero ocho veces, y otra le pedía al historial 282 ficheros de uno en uno. Un solo navegador por tanda, y una sola consulta al historial que devuelve todos los ficheros de golpe.

El servidor contestó 35 segundos. Una sola muestra, así que subí otro cambio para tener la segunda: 49. Por debajo del minuto las dos, pero el margen real son once segundos, no veinticinco.

Lo que me llevo

Dos veces en una mañana, el sitio donde el código se ejecuta me dijo algo que el sitio donde lo escribí no podía decirme. La primera, un fallo que solo existe en un disco más lento. La segunda, que mi optimización optimizaba una máquina que no era la suya.

Suelo escribir aquí sobre sistemas que fallan sin avisar. Este es un primo cercano: la prueba que avisa, pero en el sitio equivocado. Un verde en mi máquina es una afirmación sobre mi máquina. Cuando lo que me importa es otra, la pregunta no es «¿pasa?», sino «¿pasa allí?». Y si no puedo ir allí, lo mínimo es parecerme: dos núcleos, un disco más lento, y dos muestras antes de creerme un número.

← todas las entradas