Com­pi­la­to­re vs in­ter­pre­te: spie­ga­zio­ne e dif­fe­ren­za

Nella scelta di un lin­guag­gio di pro­gram­ma­zio­ne sono due gli aspetti da con­si­de­ra­re: da un lato, il lin­guag­gio deve offrire tutti gli elementi co­sti­tu­ti­vi necessari per il progetto software pia­ni­fi­ca­to. Dall’altro, la pro­gram­ma­zio­ne e l’at­tua­zio­ne di questo progetto dovrebbe essere il più semplice possibile. Una buona leg­gi­bi­li­tà e sem­pli­ci­tà del codice di pro­gram­ma­zio­ne sono le carte vincenti decisive per garantire quest’ultimo, in quanto queste ca­rat­te­ri­sti­che sem­pli­fi­ca­no non solo l’in­tro­du­zio­ne e l’ap­pren­di­men­to, ma anche l’ap­pli­ca­zio­ne quo­ti­dia­na di un lin­guag­gio di pro­gram­ma­zio­ne.

Affinché le istru­zio­ni di un programma scritto possano essere comprese da un computer o da un pro­ces­so­re, il codice sorgente dei moderni linguaggi di pro­gram­ma­zio­ne deve prima essere con­ver­ti­to in una forma leggibile dalla macchina. A seconda del lin­guag­gio di pro­gram­ma­zio­ne, quest’ope­ra­zio­ne viene eseguita da un com­pi­la­to­re o da un in­ter­pre­te. Cosa sono esat­ta­men­te questi due strumenti? E in cosa dif­fe­ri­sco­no l’uno dall’altro?

Un in­ter­pre­te è un programma per computer che elabora il codice sorgente di un progetto software durante il suo runtime, cioè mentre è in ese­cu­zio­ne, e funge da in­ter­fac­cia tra quel progetto e il pro­ces­so­re. Un in­ter­pre­te procede sempre riga per riga di codice, in modo che le singole istru­zio­ni in­di­vi­dua­li siano lette, ana­liz­za­te e preparate una dopo l’altra per il pro­ces­so­re. Questo principio si applica anche alle istru­zio­ni ri­cor­ren­ti, che vengono eseguite ogni volta che è il loro turno. Gli in­ter­pre­ti uti­liz­za­no le proprie librerie interne per elaborare il codice del software: una volta che una riga di codice sorgente è stata con­ver­ti­ta nelle cor­ri­spon­den­ti istru­zio­ni leggibili dalla macchina, viene inoltrata di­ret­ta­men­te al pro­ces­so­re.

Il processo di con­ver­sio­ne non è com­ple­ta­to fino a quando tutto il codice non è stato in­ter­pre­ta­to ed è in­ter­rot­to in corso d’opera solo se si verifica un errore durante l’ela­bo­ra­zio­ne, cir­co­stan­za che sem­pli­fi­ca no­te­vol­men­te la gestione degli errori, poiché la linea di codice pro­ble­ma­ti­ca viene iden­ti­fi­ca­ta non appena si verifica l’errore.

Un com­pi­la­to­re è un programma per computer che traduce l’intero codice sorgente di un progetto software nel lin­guag­gio macchina prima che sia eseguito. Solo allora il progetto è eseguito dal pro­ces­so­re, che possiede tutte le istru­zio­ni ne­ces­sa­rie in lin­guag­gio macchina. Vale a dire che il pro­ces­so­re dispone di tutti i com­po­nen­ti necessari per eseguire il ri­spet­ti­vo software, elaborare input e generare output. In molti casi, tuttavia, durante il processo di com­pi­la­zio­ne avviene una fase in­ter­me­dia cruciale: prima della tra­du­zio­ne finale nel lin­guag­gio macchina, la maggior parte dei com­pi­la­to­ri con­ver­to­no il codice sorgente in un codice in­ter­me­dio (chiamato anche “codice oggetto”), che è spesso adatto a diverse piat­ta­for­me e può essere uti­liz­za­to anche da un in­ter­pre­te.

Durante la ge­ne­ra­zio­ne del codice, i com­pi­la­to­ri de­ter­mi­na­no quali istru­zio­ni sono trasmesse al pro­ces­so­re e in quale ordine. Se le istru­zio­ni non sono connesse tra loro, il pro­ces­so­re può elaborare le istru­zio­ni in parallelo.

Sia i com­pi­la­to­ri, sia gli in­ter­pre­ti hanno lo scopo di con­ver­ti­re il codice scritto di un software in una forma ese­gui­bi­le e leggibile dalla macchina. Senza questa tra­du­zio­ne, i pro­ces­so­ri in­for­ma­ti­ci non sarebbero in grado di eseguire programmi in linguaggi quali C, C++, PHP, Python o Ruby, tutti strumenti in­di­spen­sa­bi­li per l’uso di PC, laptop e smart­pho­ne. Le brevi de­scri­zio­ni pre­ce­den­ti hanno già di­mo­stra­to che esistono alcune dif­fe­ren­ze so­stan­zia­li tra com­pi­la­to­ri e in­ter­pre­ti, che devono essere prese in con­si­de­ra­zio­ne nella scelta del lin­guag­gio di pro­gram­ma­zio­ne ap­pro­pria­to per un nuovo software. La seguente tabella riassume i punti più im­por­tan­ti del confronto “com­pi­la­to­re vs in­ter­pre­te”:

Le dif­fe­ren­ze tra com­pi­la­to­re e in­ter­pre­te mostrano anche i punti di forza e di debolezza della scelta di tra­du­zio­ne del codice del programma: i programmi con in­ter­pre­ti possono essere eseguiti im­me­dia­ta­men­te e sono quindi avviati molto più ve­lo­ce­men­te. Inoltre, lo sviluppo è molto più facile che con un’ap­pli­ca­zio­ne compilata, perché il processo di debug (cioè la cor­re­zio­ne degli errori) avviene linea per linea. Nel caso di un software con com­pi­la­to­re, prima di poter gestire gli errori o avviare l’ap­pli­ca­zio­ne, il codice deve essere prima com­ple­ta­to. Una volta che il programma è in ese­cu­zio­ne, tuttavia, i servizi del com­pi­la­to­re non sono più necessari, mentre un in­ter­pre­te continua a uti­liz­za­re la potenza di calcolo.

Per com­pen­sa­re i punti deboli delle due soluzioni di tra­du­zio­ne, esiste il co­sid­det­to com­pi­la­to­re just-in-time (in ingl. “tem­pe­sti­vo”, “puntuale”). Questo par­ti­co­la­re tipo di com­pi­la­to­re, che a volte è chiamato anche compreter (da compilator e interpreter), traduce il codice del programma come l’in­ter­pre­te, cioè solo durante l’ese­cu­zio­ne. In questo modo, all’alta velocità di ese­cu­zio­ne (grazie al com­pi­la­to­re) si aggiunge un processo di sviluppo sem­pli­fi­ca­to.

Uno degli esempi più noti di lin­guag­gio basato sulla com­pi­la­zio­ne just-in-time è Java: come com­po­nen­te del Java Runtime En­vi­ron­ment (JRE), tale com­pi­la­to­re JIT migliora le pre­sta­zio­ni delle ap­pli­ca­zio­ni Java con­ver­ten­do il codice byte pre­ce­den­te­men­te generato in lin­guag­gio macchina durante l’ese­cu­zio­ne.