Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Errori e debugger7. I bug silenziosip. 156

I bug silenziosi

Quando il programma gira e il risultato è sbagliato

  • 10 minuti di lettura

Fino a qui gli errori ti dicevano tutto: un nome, una riga, un traceback da leggere dal basso. Python si fermava e ti indicava il punto.

I bug di questo capitolo non si fermano. Il programma parte, arriva in fondo, stampa un risultato. Solo che il risultato è sbagliato. Nessun Traceback, nessuna riga rossa, nessun nome da cercare. Il codice è scritto bene: fa solo un'altra cosa da quella che volevi.

Per questo sono i più cari. Un errore con il traceback lo trovi in un minuto. Un bug silenzioso può restare in un programma per settimane, perché nessuno ha motivo di guardarlo.

Il test rosso senza traceback

Dove li scopri? Quasi sempre in un test. Un test è un piccolo programma che chiama la tua funzione con dei dati e confronta quello che torna con quello che deve tornare. Quando i due non coincidono il test diventa rosso, ma non c'è nessun traceback del tuo codice: la tua funzione non si è rotta, ha risposto. È il test che si è accorto che la risposta è sbagliata.

La funzione è una media dei ritardi:

Python
def ritardo_medio(ritardi):
    return sum(ritardi) // len(ritardi)

E questo è quello che dice pytest (come si lancia e come si legge è in Lanciare i test):

>       assert ritardo_medio([2, 3, 4, 5]) == 3.5
E       assert 3 == 3.5
E        +  where 3 = ritardo_medio([2, 3, 4, 5])

Tre righe, e dicono quasi tutto:

RigaCosa dice
> assert ritardo_medio([2, 3, 4, 5]) == 3.5La riga del test che è caduta, con il segno > davanti
E assert 3 == 3.5A sinistra c'è quello che la funzione ha restituito (3), a destra quello che il test voleva (3.5)
E + where 3 = ritardo_medio([2, 3, 4, 5])Da quale chiamata viene il 3, con i valori che le erano arrivati

Non dice dove nella funzione. Dice solo che il risultato e l'attesa sono diversi, e di quanto. Il lavoro di cercare la riga è tuo, e il metodo è nella prossima sezione.

Prevedi, osserva, confronta

Come si cerca un punto che non conosci? Con il debugger, ma non basta guardare: se guardi senza sapere cosa aspettarti, ogni valore sembra ragionevole. Il metodo ha tre mosse.

         ┌────────────────────────────────────────────────────┐
         │                                                    │
   1. PREVEDI            2. OSSERVA              3. CONFRONTA
   «alla prossima        F10: la riga gira,      due valori uguali?
    riga mi aspetto       guardo VARIABLES        sì → avanti, giro dopo giro
    totale = 42»                                  no → eccolo
         │                                                    │
         └──────────────── ancora un passo ───────────────────┘

   Il bug sta dove la previsione e quello che vedi si separano.

Prevedi. Prima di premere F10 (su Mac fn+F10) dici, ad alta voce o su un foglio, cosa vedrai nel pannello VARIABLES dopo quella riga. Non il risultato finale: il valore di quella variabile, adesso.

Osserva. Premi F10. La riga gialla è stata eseguita. Guardi VARIABLES.

Confronta. Il valore è quello che avevi detto? Se sì, un altro passo. Se no, ti sei fermato nel punto giusto: non cercare altrove, il bug è in quella riga, o in quella appena sopra.

Un esempio piccolo. La funzione somma i passeggeri saliti in tre giri e il test dice assert 8 == 50:

Python
def saliti_totali(giri):
    totale = 0
    for saliti in giri:
        totale = saliti
    return totale

Con giri = [30, 12, 8] metti un breakpoint sulla riga totale = saliti e premi F5 a ogni giro. Prima di ogni fermata prevedi, poi guardi:

GirosalitiPrevedo che totale valga dopo la rigaVedo totale dopo la riga
1303030
2124212
38508

Il giro 1 non dice niente: 0 + 30 e 30 sono la stessa cosa. Il giro 2 sì: avevo previsto 42, vedo 12. Il bug è nella riga che ho appena eseguito: totale = saliti sostituisce, non somma.

giri = [30, 12, 8] saliti = 12 totale = 12girisalititotalelist30012182int12int12
VARIABLES dopo la riga del giro 2

Attenzione a quando guardi. Alla fermata la riga gialla non è ancora stata eseguita: per vedere totale dopo la riga devi premere F10, oppure guardare la fermata successiva. Se questa frase non ti torna, rileggi Il debugger.

Il commento prima della correzione

Hai trovato la riga. Ora la tentazione è correggerla subito. Prima fai un'altra cosa: sopra la riga, scrivi un commento.

Python
    for saliti in giri:
        # BUG: totale = saliti sostituisce il totale con l'ultimo giro, non lo somma.
        totale = saliti

Il formato è sempre questo: # BUG: (le tre lettere maiuscole e i due punti), poi cosa hai visto e perché è sbagliato. Una frase. Tre ragioni:

  1. Ti obbliga a dirlo. Se non riesci a scrivere perché è sbagliato, non hai ancora trovato il bug: hai trovato una riga vicina. Meglio accorgertene prima di cambiare il codice.
  2. Chi legge dopo di te (tu fra un mese, un collega) capisce che quella riga è stata un problema, e perché ora è diversa.
  3. Il commento resta nel codice, e si può cercare: grep "# BUG:" ti dà la storia dei guai di un file. In Rifattorizzare senza rompere lo stesso commento serve a tenere i bug separati dalle pulizie.

Solo dopo correggi. Nel nostro caso totale = totale + saliti: il commento resta, la riga cambia.

Correggere il minimo e rilanciare tutto

La correzione giusta è la più piccola che spiega il commento. Di solito una riga, a volte una parola. Se per correggere stai riscrivendo mezza funzione, probabilmente non hai capito ancora il bug.

E poi si rilanciano tutti i test, non solo quello che era rosso. Per due motivi.

Il primo: una correzione può aggiustare un test e romperne un altro. Il secondo, più subdolo: una correzione furba fa passare il test rosso senza correggere niente.

Python
def ritardo_medio(ritardi):
    if len(ritardi) == 4:    # il test usa quattro treni: ecco il trucco
        return 3.5
    return sum(ritardi) // len(ritardi)

Il test dei quattro treni diventa verde. Ma un test con due treni ([1, 2], deve dare 1.5) è ancora rosso, e lo vedi solo se lanci tutto. Regola: non scrivere mai un if che riconosce il caso del test. Il test è un esempio del comportamento, non il comportamento.

Anche il contrario vale: un test verde non prova che il codice sia giusto. Nel test del // qui sopra, ritardo_medio([7]) dà 7 e passa, con la riga sbagliata. Un test verde dice solo che quel caso va bene.

Le mosse, in ordine

#MossaCome
1Leggi il test rossoCosa torna (a sinistra di ==), cosa doveva tornare (a destra), con quali dati
2PrevediA parole: cosa dovrebbe fare la funzione su quei dati, riga per riga
3FermatiUn breakpoint dentro la funzione, tasto destro sul test → Debug Test (come si fa)
4Osserva e confrontaF10 un passo alla volta, VARIABLES (o WATCH) contro la tua previsione
5Scrivi il commento# BUG: cosa ho visto, e perché è sbagliato, sopra la riga
6Correggi il minimoUna riga, se si può
7Rilancia tutti i testAnche quelli già verdi. Poi, se c'è, rilancia il programma

Quando una mossa non basta, cambi strumento, non metodo: WATCH per un'espressione che vuoi tenere d'occhio, F11 per entrare in una funzione che chiami.

Che bug sono

I bug silenziosi hanno quasi sempre dietro un'idea sbagliata su Python, non una svista di battitura. Una riga ha l'aria di fare una cosa e ne fa un'altra: un confronto che sembra su numeri ed è su testo, una lista che sembra copiata ed è la stessa, un return che sembra in fondo ed è nel mezzo. Il capitolo non li spiega tutti: li trova. Dove serve il concetto, c'è il rimando al capitolo che lo spiega, per esempio Le funzioni o Etichette e scatole.

Ricorda

  • Un test rosso senza traceback vuol dire che la funzione gira e risponde male. A sinistra di == c'è quello che ha restituito.
  • Prevedi, osserva, confronta: la previsione viene prima di F10. Il bug sta dove le due cose si separano.
  • Prima di correggere, sopra la riga: # BUG: cosa ho visto, e perché è sbagliato.
  • Correggi il minimo. Mai un if che riconosce il caso del test.
  • Rilancia tutti i test: un test verde non dice che il codice è giusto, solo che quel caso va bene.