Ciao, e benvenuto nella nona puntata della quarantaseiesima stagione. Ho raccontato TypeScript con ammirazione, e se la merita. Ma oggi, come sempre verso la fine, mettiamo sul tavolo il conto onesto, senza né demolire né difendere per riflesso. TypeScript ha un prezzo, e dei limiti reali, e uno di questi è il malinteso più pericoloso di tutti. E però, alla fine, ha vinto, e a ragione. Oggi guardiamo il prezzo e i limiti: la rete che non è una garanzia.
Partiamo dal prezzo, perché va detto chiaro. Primo: TypeScript non è gratis. C'è un passaggio in più prima di eseguire, una curva di apprendimento, la cerimonia dei tipi da scrivere, e la tana del coniglio della puntata scorsa, dove la complessità può esplodere. Per un piccolo script, per un esperimento veloce, è un cappotto pesante per una passeggiata: eccessivo. Torna la bussola di sempre, il giusto strumento per la forma del problema. Il costo è piccolo per un programma grande e duraturo, e sproporzionato per due righe buttate giù in fretta.
Voglio darti il limite più profondo, perché è il malinteso numero uno. Ricordi la prima puntata? I tipi svaniscono quando il codice gira. E da questo discende il limite più importante e più frainteso: i tipi non possono proteggerti dal mondo esterno. I dati che arrivano da una rete, da un file, da un utente, da una base di dati: TypeScript non ha idea di che forma abbiano davvero. Può solo credere a ciò che gli hai detto tu. Se gli dici il server restituisce un utente, e il server restituisce spazzatura, TypeScript non ha controllato nulla: i tipi erano una promessa sul tuo codice, non una guardia alla porta. Al confine col mondo, il correttore se n'è già andato.
Voglio insistere su questo, perché è dove sbagliano quasi tutti. È il fraintendimento più comune e più pericoloso: prendere il segno di spunta verde per una protezione contro la realtà. Non lo è. Al confine col mondo esterno ti serve ancora un controllo vero, mentre il codice gira: guardare davvero cosa è arrivato, e verificarlo, prima di crederci. C'è persino un tipo apposta che dice non so ancora cosa sia questo, e ti costringe a controllarlo prima di poterlo usare, l'opposto della via di fuga di cui parlammo. I tipi sono un contratto dentro il tuo programma, non un buttafuori alla sua porta d'ingresso.
Voglio raccogliere gli altri limiti, perché completano il quadro. E ci sono gli altri fili che abbiamo già tirato. Che TypeScript può mentire di proposito, non è a tenuta stagna, come vedemmo. E che è sicuro solo quanto imposti il cursore: una base piena di vie di fuga è protezione solo di facciata. Mettili insieme e il punto onesto è uno: TypeScript riduce una categoria di errori, non ti dà la certezza. È un ottimo sistema di allarme, non una garanzia. E confondere le due cose ti dà una falsa sicurezza, che a volte è peggio di nessuna sicurezza, perché abbassi la guardia proprio dove servirebbe alzarla.
Voglio però riequilibrare, perché sarei ingiusto a fermarmi ai difetti. E tuttavia, detto tutto questo, TypeScript ha vinto, e giustamente. Per programmi di una qualsiasi dimensione seria, costruiti da squadre nel tempo, il costo è piccolo contro il regalo: l'editor che ti fa da partner, il vuoto reso visibile, il rinominare in sicurezza, i tipi come documentazione viva che dice cosa intendevi. Il mondo non l'ha adottato per moda: l'ha adottato perché conviene. I difetti sono veri, ma il bilancio, sul lavoro reale, pende nettamente dalla parte del sì.
Voglio darti l'immagine e la posizione matura, perché è tutto qui. Pensa alle cinture di sicurezza e agli airbag. Enormemente utili, riducono i danni in modo drastico. E però non sono una garanzia di non farti mai male. Il pericolo non è la cintura: è il guidatore che, sentendosi al sicuro, guida come se la strada non potesse toccarlo. La posizione matura è questa: usa la rete in pieno, alza il cursore, verifica i confini col mondo mentre il codice gira, resisti alla tana dei tipi troppo astuti, e non scambiare mai il segno verde per una prova. Usa la rete sapendo che è una rete, non un pavimento.
Per oggi ci fermiamo qui. Il conto onesto di TypeScript: non è gratis, ha un costo che per un piccolo script è eccessivo, giusto strumento per il problema. Il limite più profondo viene dalla prima puntata: i tipi svaniscono, quindi non ti proteggono dal mondo esterno, e prendere il verde per una protezione contro la realtà è il malinteso più pericoloso, ai confini serve un controllo vero a runtime. Aggiungi che può mentire apposta e che è sicuro quanto lo imposti: riduce gli errori, non dà certezza, è un allarme, non una garanzia. E però ha vinto a ragione, perché sul lavoro reale il bilancio pende nettamente dal sì. Come cinture e airbag: usali in pieno, ma ricorda che è una rete, non un pavimento. Nella prossima e ultima puntata tiriamo le somme. Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.