Ciao, e benvenuto nella quinta puntata della sessantasettesima stagione. Finora ho lodato molto il compilatore: traduttore capace, ottimizzatore instancabile, insegnante severo. Oggi arriva la puntata onesta, quella che mette dei limiti a tutto questo. Perché c'è una verità sul compilatore che, se la dimentichi, ti farà perdere ore di sonno. Il compilatore obbedisce, non capisce.
Partiamo dalla distinzione fondamentale, perché tutto nasce da lì. Il compilatore non sa cosa volevi fare. Sa solo cosa hai scritto. Sono due cose diverse, e l'abisso tra loro è dove vivono i bug. Tu avevi in testa un'intenzione: fai questo. Sulla tastiera è finita una frase leggermente diversa: fai quest'altro. Il compilatore prende la frase, non l'intenzione. La traduce alla perfezione, con la sua fedeltà assoluta. E ti consegna un programma che fa esattamente quello che hai scritto, anche quando è l'opposto di quello che volevi.
Vediamo la conseguenza più dura: traduce i tuoi errori con la stessa cura dei tuoi successi. Se scrivi per sbaglio una logica sbagliata, ma scritta correttamente, il compilatore non batte ciglio. Non c'è nessun errore di grammatica, nessun controllo violato: la frase è valida, semplicemente dice una cosa stupida. E lui la traduce fedelmente in un programma che fa quella cosa stupida, in modo impeccabile e veloce. Il compilatore garantisce che il tuo codice sia ben formato, mai che sia giusto. La differenza tra ben formato e giusto è tutta responsabilità tua.
Voglio essere preciso su cosa può e cosa non può prendere, perché confonderli è pericoloso. Il compilatore prende bene una famiglia di errori: quelli di forma e quelli di coerenza. Una parola scritta male, una struttura rotta, un nome mai definito, due cose incompatibili messe insieme. Sono errori formali, e lì è un guardiano prezioso. Ma è completamente cieco davanti agli errori di intenzione: hai sommato quando volevi sottrarre, hai invertito una condizione, hai dimenticato un caso. Formalmente tutto torna, e lui passa oltre. Nessun compilatore, per quanto sofisticato, può leggerti nel pensiero e sapere cosa avevi in mente.
Vediamo il lato più insidioso, quello dell'ottimizzazione. Ti ricordi la regola del come se? Il compilatore riscrive il tuo codice, purché il comportamento resti identico. Ma quella libertà si appoggia su un patto: che tu abbia seguito le regole del linguaggio. Ci sono zone in cui le regole dicono chiaramente cosa non devi fare, una specie di terra di nessuno. Se ci finisci, il compilatore non è obbligato a fare la cosa ragionevole. Può ottimizzare partendo dal presupposto che tu quella cosa non l'abbia mai fatta, e produrre un programma che si comporta in modi sorprendenti, difficili da spiegare. Non è cattiveria: è che gli hai dato una premessa falsa, e lui ci ha costruito sopra.
Voglio smontare un mito, perché è una mezza verità pericolosa. Si dice: il compilatore ha sempre ragione. È vero a metà. Quando si lamenta, di solito ha ragione lui, e l'errore è tuo: conviene ascoltarlo invece di combatterlo. Ma quando non si lamenta, non sta dicendo il tuo programma è giusto. Sta dicendo soltanto: non ho trovato niente di formalmente sbagliato. È una frase molto più modesta di come la interpretiamo. Il silenzio del compilatore non è un certificato di correttezza. È solo l'assenza di errori formali, che è un'altra cosa.
Ecco l'immagine che fissa tutto questo, così non la scordi. Pensa al genio della lampada che esaudisce i desideri alla lettera. Gli chiedi ricchezza, e ti riempie la stanza d'oro fino a bloccare la porta. Non ti ha frainteso: ha fatto esattamente ciò che hai detto, non ciò che intendevi. È potentissimo e assolutamente ubbidiente, e proprio per questo pericoloso, perché non colma lui la distanza tra le tue parole e i tuoi desideri: quella tocca a te. Il compilatore è quel genio. Esaudisce il codice che scrivi, alla lettera. Sta a te far combaciare le parole con le intenzioni.
Resta la lezione di fondo, ed è liberatoria più che scoraggiante. Il compilatore ti toglie un peso enorme, gli errori formali, e questo è un regalo. Ma non può togliertene un altro, il più importante: pensare bene a cosa vuoi, e dirlo con precisione. Quella responsabilità non è delegabile a nessuno strumento, per quanto brillante. Ed è, in fondo, una buona notizia: significa che il pensiero conta ancora, che la parte davvero difficile e davvero tua non te la porta via nessuno. Lo strumento obbedisce. Capire cosa chiedergli, quello resta il mestiere.
Per oggi ci fermiamo qui. Abbiamo messo il limite giusto: il compilatore obbedisce, non capisce. Sa cosa hai scritto, non cosa volevi, e l'abisso tra le due cose è dove vivono i bug. Traduce i tuoi errori di logica con la stessa fedeltà dei tuoi successi: garantisce ben formato, mai giusto. Prende gli errori di forma, è cieco su quelli di intenzione. E la sua ottimizzazione presuppone che tu abbia seguito le regole. Quando si lamenta di solito ha ragione; quando tace, dice solo non ho trovato errori formali. Come un genio che esaudisce alla lettera. La lezione: pensare bene a cosa vuoi resta tua responsabilità. Nella prossima puntata: compilare o interpretare? Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.