Depuración de simulaciones

01 · Punto de partida

Depurar simulaciones no es depurar un CRUD

En un programa común, un bug suele mostrarse siempre igual. En una simulación, el bug se esconde detrás del tiempo y del azar: aparece en el paso 47, solo con cierta semilla, solo cuando la cola se vacía un martes simulado. Adivinar y tocar código al azar solo agrega bugs nuevos.

• ¿Cómo reproducir el fallo a voluntad?
• ¿Cómo saber el primer instante donde miente?
• ¿Cómo reducir 500 líneas a 10 culpables?
• ¿Cómo saber que el arreglo no rompió otra cosa?

02 · Definición

Qué hace especial al bug de simulación

03 · Método

El protocolo en 5 pasos

1. 1
   Reproducir con semilla y caso mínimo.

   Fijá semilla, recortá pasos y datos hasta el ejemplo más chico que aún falla. Si no reproduce a voluntad, no depurés: estabilizá primero.

2. 2
   Leer la traza, no el gráfico.

   Imprimí (t, antes → después, evento). El gráfico muestra el síntoma; la traza muestra el primer paso imposible.

3. 3
   Bisecar el tiempo.

   Si falla en 12 pasos pero no en 6, el t* está en 7…12. Partí el intervalo hasta dar con el primer desvío exacto.

4. 4
   Hipótesis de una sola causa.

   Formulá «creo que en t* la salida se aplica dos veces» y diseñá un experimento que la refute. Una hipótesis por vez.

5. 5
   Fijar y blindar con regresión.

   Arreglá, agregá el caso mínimo a la suite del Tema 3 y corré todo. Un bug cazado sin test nuevo volverá.

04 · Herramientas

Trazas, prints estructurados y visores

Heisenbug

Bug que desaparece al observarlo (prints que cambian el timing, azar distinto). Se fija con semilla y traza a archivo, no con prints invasivos.

Delta debugging

Recortar input, pasos y código hasta el mínimo que falla. Si con 3 pasos ya falla, no mires 100.

Punto de observación

Invariante impreso en cada paso (0 ≤ nivel ≤ tope). El primer «ROTO» es el t*.

05 · Representación en Python

Cazar con traza comparada y bisección

El patrón profesional: una función que genera traza, una que compara contra la esperada y una bisección que encuentra t* automáticamente.

def sim_bug(nivel, entrada, salida, tope, pasos):
    h = []
    for t in range(pasos):
        nivel = nivel + entrada - salida  # BUG: falta max(0, min(tope, ...))
        h.append(nivel)
    return h

def esperada(nivel, entrada, salida, tope, pasos):
    h = []
    for t in range(pasos):
        nivel = max(0, min(tope, nivel + entrada - salida))
        h.append(nivel)
    return h

esp = esperada(2, 1, 3, 14, 6)
mal = sim_bug(2, 1, 3, 14, 6)
for t, (e, m) in enumerate(zip(esp, mal), start=1):
    marca = " <-- DIVERGE" if e != m else ""
    print(f"t={t}: esperada={e} programa={m}{marca}")

La primera línea con DIVERGE es el t*: ahí nace el bug, lo demás es arrastre.

Bisección automática del primer desvío

# Reusa esp y mal del bloque anterior
def primer_desvio(esp, mal):
    lo, hi, ans = 0, len(esp) - 1, None
    while lo <= hi:
        mid = (lo + hi) // 2
        if esp[:mid+1] == mal[:mid+1]:
            lo = mid + 1
        else:
            ans = mid + 1  # en base 1
            hi = mid - 1
    return ans

print("t* =", primer_desvio(esp, mal))
print("Arreglo: envolver con max(0, min(tope, ...)) y agregar test")

06 · Exploración

Laboratorio: la caza del t*

Elegí el bug inyectado (0 = ninguno, 1 = desfase, 2 = signo invertido, 3 = piso olvidado) y la entrada. El gráfico compara la esperada (lima) con el programa (naranja), marca el primer desvío con un círculo rojo y te da la pista. Tu trabajo: predecir el t* antes de mirar el veredicto.

Salida fija en 2, inicio en 10 y tope en 14. La bisección se hace sola: achicá «ver hasta el paso» para partir el intervalo como harías depurando (¿falla en 6? ¿en 3?).

Preguntas para explorar

1. Con bug 1 (desfase) y entrada 3: ¿cuál es el t*? Achicá el zoom a 6, luego a 3. ¿En cuántas particiones lo aislás?
2. Cambiá a bug 3 (piso olvidado) con entrada 1. ¿El t* aparece al inicio o cuando cruza cero? ¿Por qué la traza inicial «parece» correcta?
3. Con bug 2 (signo invertido), ¿la divergencia crece o se mantiene? ¿Qué invariante lo delataría en un solo paso?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: mínimo reproducible

Reducí este fallo de 12 pasos al mínimo que aún diverge.

def esperada(n, e, s, tope, pasos):
    h = []
    for _ in range(pasos):
        n = max(0, min(tope, n + e - s))
        h.append(n)
    return h

def rota(n, e, s, tope, pasos):
    h = []
    for _ in range(pasos):
        n = n + e - s  # sin piso/techo
        h.append(n)
    return h

for pasos in [12, 6, 3, 2, 1]:
    e = esperada(2, 1, 3, 14, pasos)
    r = rota(2, 1, 3, 14, pasos)
    print(pasos, e == r, r)

Ejercicio 2: leer la traza como un detective

¿En qué paso nace el bug y qué hipótesis sugiere?

traza = [(1, 10, 11), (2, 11, 12), (3, 12, 12), (4, 12, 12)]
# (t, esperada, programa)
for t, e, m in traza:
    print(t, e, m, "<-- t*" if e != m else "")

Ejercicio 3: blindar con regresión

Convertí el bug del piso en un test con nombre que quede para siempre.

def sim(nivel, e, s, tope, pasos):
    h = []
    for _ in range(pasos):
        nivel = max(0, min(tope, nivel + e - s))
        h.append(nivel)
    return h

def test_piso_no_negativo():
    assert sim(2, 1, 3, 14, 3) == [0, 0, 0]

test_piso_no_negativo()
print("Regresión OK: el bug del piso no volverá en silencio")

09 · Síntesis

Ideas para recordar

En el próximo tema cruzaremos el puente hacia el mundo real: la validación frente al sistema real.