Compilatore, interprete e transpiler
Compilatore, interprete e transpiler
Questo codice ha un errore alla riga 3:
console.log("Inizio il calcolo della media");
const voti: number[] = [28, 30, 25];
const media: number = "27.6";
console.log(media);
Nel notebook la cella non stampa niente, nemmeno la prima riga, che era corretta. Il kernel ha trovato l'errore prima di eseguire qualunque cosa. Se scrivete lo stesso codice in JavaScript, senza tipi, la prima riga si stampa e il programma va avanti con una stringa al posto di un numero. Per capire la differenza servono tre parole: compilatore, interprete, transpiler.
Il problema di partenza
Il processore capisce solo istruzioni molto semplici, scritte in linguaggio macchina: numeri che vogliono dire "carica questo valore", "somma queste due celle", "salta a quell'istruzione". Scrivere un programma così è lentissimo. Per questo esistono i linguaggi di programmazione, fatti per essere letti e scritti da persone. Qualcuno però deve tradurli in istruzioni per il processore. Ci sono due modi di farlo.
Compilatore
Un compilatore legge tutto il programma, lo controlla e lo traduce in un altro linguaggio, di solito il linguaggio macchina. La traduzione avviene una volta, prima di eseguire. Il risultato si esegue poi quante volte si vuole, senza ritradurlo.
Siccome legge tutto il codice prima di partire, il compilatore trova certi errori senza eseguire niente: un nome scritto male, un testo dove serve un numero. C, C++, Rust e Go sono linguaggi compilati.
Interprete
Un interprete legge il programma ed esegue le istruzioni man mano, una dopo l'altra. Non c'è un passaggio separato di traduzione. Si parte subito, e un errore salta fuori solo quando il programma arriva alla riga che lo contiene. Se quella riga si esegue solo il 29 febbraio, l'errore salta fuori il 29 febbraio.
Python e JavaScript sono nati come linguaggi interpretati. Oggi i motori JavaScript, come V8 dentro Chrome e Node.js, fanno di più: compilano i pezzi di codice usati spesso mentre il programma gira, per renderli più veloci. Per chi scrive il codice, però, il comportamento resta quello di un interprete. Nessuno controlla i tipi prima di partire.
Transpiler
Un transpiler è un compilatore che traduce da un linguaggio a un altro di livello simile, leggibile da una persona. Non produce linguaggio macchina.
TypeScript funziona così. Il compilatore tsc:
- legge tutto il codice TypeScript;
- controlla i tipi ed elenca gli errori;
- scrive il codice JavaScript corrispondente, togliendo i tipi.
| TypeScript | JavaScript prodotto |
|---|---|
const voti: number[] = [28, 30, 25]; |
const voti = [28, 30, 25]; |
let media: number = 0; |
let media = 0; |
const piove: boolean = false; |
const piove = false; |
Il JavaScript prodotto lo esegue poi Node.js o il browser, cioè un interprete. Quindi in TypeScript il controllo dei tipi avviene prima, e quando il programma gira i tipi non ci sono più. Il notebook 02-tipi-e-compilatore.ipynb lo mostra con ts.transpile, che fa la traduzione senza il controllo.
Cosa succede quando premete Shift+Invio
Il kernel tslab del notebook fa i tre passi di tsc su quella cella:
| Passo | Se va male |
|---|---|
| Controlla i tipi | Mostra l'errore e si ferma: la cella non viene eseguita |
| Traduce in JavaScript | |
| Esegue il JavaScript | Errore a runtime: le righe prima dell'errore hanno già stampato, le successive no |
Ecco perché nell'esempio iniziale non si stampa nemmeno la prima riga: il controllo riguarda tutta la cella, prima che parta.
Perché un errore prima costa meno
Lo stesso errore costa molto diverso a seconda di quando lo trovate:
| Quando lo trovate | Cosa costa |
|---|---|
| Mentre scrivete, con il compilatore | Pochi secondi: il messaggio dice riga e colonna |
| Provando il programma | Minuti: dovete accorgervi che il risultato è strano e cercare da dove viene |
| Quando il programma è già usato da altri | Ore o giorni: un utente segnala un problema, bisogna riprodurlo, correggerlo, ripubblicare. Intanto i dati sbagliati sono già stati salvati |
Il compilatore non trova tutti gli errori. Un indice fuori dall'array, una divisione per zero, una formula sbagliata passano il controllo. Quelli che trova, però, non arrivano mai a runtime, e sono tanti: TypeScript esiste per questo.
In sintesi
| Parola | Quando traduce | In cosa | Trova gli errori di tipo |
|---|---|---|---|
| Compilatore | Prima di eseguire, tutto il programma | Di solito linguaggio macchina | Prima di eseguire |
| Interprete | Durante l'esecuzione, un'istruzione alla volta | Esegue direttamente | Solo quando arriva alla riga |
| Transpiler | Prima di eseguire, tutto il programma | Un altro linguaggio leggibile (TypeScript → JavaScript) | Prima di eseguire |