Ciao, e benvenuto nella prima puntata della sessantanovesima stagione. Nelle ultime due stagioni abbiamo parlato di cose profonde: come un compilatore preserva il significato di un programma, e cos'è, esattamente, quel significato. Abbiamo perfino incontrato l'idea che si possa dimostrare, con rigore matematico, che un programma è corretto. Ma tu lo sai bene: quasi nessuno, nel lavoro di tutti i giorni, dimostra teoremi sul proprio codice. Facciamo un'altra cosa, molto più umile e molto più diffusa. Scriviamo dei test. E questa stagione parla proprio di quello.
Partiamo da una domanda che sembra banale e non lo è per niente: che cosa dimostra, davvero, un test? La risposta istintiva è: dimostra che il codice funziona. Se scrivo un test, lo lancio, e diventa verde, allora il mio codice è a posto. È qui che vive la magia, la rassicurazione comoda. E come sempre in questo podcast, oggi la smontiamo, non per toglierti fiducia, ma per dartene una più solida.
Vediamo cos'è un test, guardandolo per quello che è davvero. Un test è un esperimento. Esattamente come nel metodo scientifico: formuli un'ipotesi, dato questo ingresso mi aspetto questo risultato, poi la metti alla prova. Prepari le condizioni, esegui il pezzo di codice, e osservi se il risultato è quello che avevi previsto. Se lo è, l'esperimento è andato come speravi. Se non lo è, hai scoperto qualcosa. Non c'è niente di mistico: è la stessa cosa che fa uno scienziato in laboratorio, solo che il tuo laboratorio è il codice, la tua provetta è una funzione, e il risultato dell'esperimento è un semplice sì o no: il codice si è comportato come avevi previsto, oppure no.
E qui arriva il punto che cambia tutto. Un esperimento riuscito non dimostra che la tua teoria è vera. Dimostra soltanto che, in quel caso specifico, non l'hai smentita. Pensa a un test che verifica la tua funzione con il numero due e si aspetta quattro. Passa. Bene: cosa hai imparato? Hai imparato che, per il numero due, la funzione fa la cosa giusta. Non hai imparato niente sul numero tre, sul numero meno uno, su un numero gigantesco, sullo zero. Un test verde non dice il codice è corretto. Dice: per questo caso, non ho trovato un difetto. È una frase molto più piccola, e molto più onesta. E questa piccola onestà, come vedrai, cambia il modo in cui usi i test.
Nota quanto questa distinzione sia profonda, perché è il cuore di tutta la stagione. C'è una frase famosa nel nostro mestiere, che dice più o meno così: il testing può rivelare la presenza di errori, ma non potrà mai dimostrare la loro assenza. Fermati un attimo su questa idea. Per quanti test tu scriva, stai sempre controllando un numero finito di casi. Ma un programma, come abbiamo visto la scorsa stagione, può comportarsi in un'infinità di modi diversi, a seconda degli ingressi. Controllare mille casi, o un milione, lascia comunque fuori tutto il resto. Il testing non chiude la porta ai bug: illumina alcune stanze, e ti dice che lì, per ora, non ce ne sono.
C'è un contrasto forte con la stagione scorsa, e vale la pena vederlo bene. Là avevamo detto che, con una definizione precisa del significato, si può dimostrare la correttezza di un programma per tutti i casi possibili. È la verifica formale, potente e definitiva. Ma ha un prezzo enorme: è difficile, lenta, costosa, e si applica solo a pezzi piccoli e critici. Il testing è la strada opposta. Non ti dà la certezza assoluta, ti dà delle prove. Non copre tutti i casi, ne copre alcuni scelti bene. In cambio, è alla portata di chiunque, ogni giorno, su qualunque codice. È il compromesso pragmatico che ha conquistato il mondo. La verifica formale è il bisturi del chirurgo: preciso, potente, riservato ai casi che lo meritano. Il testing è il controllo che fai ogni giorno, su tutto, perché costa poco e rende molto.
Voglio che tu tenga stretta questa immagine, perché ci accompagnerà per dieci puntate. Tu sei lo scienziato, e il tuo codice è la natura che stai studiando. Non puoi dimostrare una legge di natura provandola una volta: puoi solo tentare di smentirla, tante volte, in tanti modi, e guadagnare fiducia ogni volta che resiste. Il testing è questo: dubbio organizzato. È l'arte di provare, in modo sistematico, a far sbagliare il tuo stesso codice, e di fidarti un po' di più ogni volta che non ci riesci.
Per oggi ci fermiamo qui. Abbiamo cambiato una convinzione comoda con una più vera. Un test non è una dimostrazione che il codice funziona: è un esperimento, e un esperimento riuscito dimostra solo che, per quel caso, non hai trovato un difetto. Il testing rivela la presenza di bug, non la loro assenza, perché controlla sempre un numero finito di casi in uno spazio sterminato. È la strada pragmatica opposta alla verifica formale: non certezza, ma prove; non tutti i casi, ma alcuni scelti bene, alla portata di tutti. E il modo giusto di pensarlo è come dubbio sistematico, il mestiere di provare a rompere ciò che hai costruito. Nella prossima puntata: l'anatomia di un test. Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.