Linguaggi di programmazione e sintassi

Approfondimento

La traduzione operata da un compilatore non è un unico passaggio, ma una catena di fasi ben distinte, oggetto di studio della teoria dei compilatori. L'analisi lessicale (scanner) spezza il testo in token elementari (parole chiave, identificatori, numeri, operatori); l'analisi sintattica (parser) verifica che i token rispettino la grammatica del linguaggio e ne costruisce l'albero sintattico; l'analisi semantica controlla la coerenza dei tipi e la dichiarazione delle variabili; seguono la generazione del codice intermedio, l'ottimizzazione e la generazione del codice macchina; infine il collegamento (linking) unisce il codice alle librerie usate. Il modello ibrido «bytecode + macchina virtuale» merita attenzione particolare: Java compila il sorgente in «bytecode», un linguaggio intermedio indipendente dalla piattaforma, che la JVM esegue interpretandolo o — per le porzioni più eseguite — compilandolo al volo in linguaggio macchina (compilazione JIT, just-in-time), conciliando così portabilità e prestazioni. Anche Python compila internamente in bytecode («.pyc») eseguito dalla propria macchina virtuale, il che mostra come «compilato» e «interpretato» non siano categorie nette ma estremi di un continuo. Sul piano concettuale i linguaggi si raggruppano poi in paradigmi — imperativo/procedurale, orientato agli oggetti, funzionale e logico — ciascuno con un diverso modo di descrivere il calcolo, dalla sequenza di comandi che modificano lo stato alla valutazione di funzioni senza effetti collaterali.

Approfondimento

La sintassi di un linguaggio si descrive rigorosamente con una grammatica formale, spesso scritta in notazione BNF (Backus-Naur Form): un insieme di regole di produzione che generano tutte e sole le frasi ben formate — la stessa nozione di grammatica che ritroveremo nella teoria della computazione e nei linguaggi di markup. Sul versante dei tipi, i linguaggi si distinguono lungo due assi indipendenti. La tipizzazione può essere statica (il tipo delle variabili è fissato e controllato alla compilazione, come in C e Java) oppure dinamica (il tipo è associato al valore e determinato a tempo di esecuzione, come in Python); ed è forte quando il linguaggio vieta conversioni implicite azzardate, debole quando le concede silenziosamente. Un concetto operativo importante è la valutazione in corto circuito (short-circuit) degli operatori logici: in «A and B», se A è falsa, B non viene nemmeno valutata perché il risultato è già deciso; ciò consente scritture idiomatiche e sicure come «k ≠ 0 and n/k > 1», dove il secondo test si esegue solo quando è lecito. Va infine ricordato che i tipi numerici hanno rappresentazione finita: gli interi a dimensione fissa possono andare in overflow oltre un certo intervallo, e i float approssimano i reali (0,1 non è rappresentabile esattamente in binario, così «0,1 + 0,2» non dà esattamente «0,3»), tema centrale ripreso nel capitolo di calcolo numerico. Distinguere il valore dal suo tipo e dalla sua rappresentazione in memoria è la chiave per prevedere il comportamento delle espressioni.

Approfondimento

Le forme di iterazione di un linguaggio reale sono, sul piano teorico, interscambiabili: un ciclo «for» su un intervallo è zucchero sintattico per un «while» con inizializzazione, condizione e aggiornamento resi espliciti («i <- 0; while i < n: corpo; i <- i + 1»). I costrutti «break» (esci dal ciclo) e «continue» (salta all'iterazione successiva) sono comodi ma vanno usati con misura: introducono uscite multiple e allontanano dall'ideale «un ingresso, un'uscita» della programmazione strutturata, quindi spesso conviene una condizione scritta meglio. Saper negare correttamente una condizione composta è cruciale e si fonda sulle leggi di De Morgan: la negazione di «A and B» è «(not A) or (not B)», quella di «A or B» è «(not A) and (not B)»; sbagliare questa trasformazione, per esempio invertendo un «and» in un «or», è una tipica fonte di errori logici nei rami di selezione. Sul fronte dei cicli enumerativi, l'errore per scarto di uno (off-by-one) nasce dai confini dell'intervallo: «range(n)» in Python genera 0, 1, ..., n−1 (n valori, ultimo escluso), mentre spesso si vorrebbe includere n. I cicli annidati, infine, moltiplicano i costi: due cicli uno dentro l'altro su n elementi eseguono il corpo interno «n²» volte — prima avvisaglia concreta della complessità quadratica «O(n²)» che analizzeremo negli algoritmi di ordinamento elementari.

Approfondimento

L'approfondimento naturale dei sottoprogrammi è la ricorsione: una funzione può richiamare sé stessa su un'istanza più piccola del problema, purché siano definiti un caso base (che arresta la discesa) e un passo ricorsivo (che riconduce il problema a uno più semplice). Il fattoriale ne è l'esempio canonico: «fatt(n) = 1 se n = 0, altrimenti n·fatt(n−1)». Ogni chiamata in sospeso è custodita in un record di attivazione (stack frame) impilato sulla pila delle chiamate (call stack), che conserva parametri, variabili locali e indirizzo di ritorno; quando si raggiunge il caso base la pila si svuota risalendo e componendo i risultati parziali. È chiaro allora perché una ricorsione senza caso base — o che non si avvicina mai ad esso — provochi il traboccamento della pila (stack overflow), l'esatto analogo del ciclo infinito per l'iterazione. Il passaggio dei parametri avviene poi secondo due modalità di fondo: per valore, dove il sottoprogramma riceve una copia dell'argomento e non può modificarne l'originale, e per riferimento, dove riceve un riferimento alla variabile del chiamante e può alterarla — distinzione che spiega molti «effetti collaterali» inattesi (per esempio quando si passa una lista). Le funzioni prive di effetti collaterali, che dipendono solo dai propri parametri e non modificano lo stato esterno, si dicono pure: sono le più facili da testare, riusare e comporre, e sono il cuore del paradigma funzionale.

Approfondimento

Il testing si organizza con metodo, non a caso. Nel testing a scatola nera (black-box) i casi si scelgono guardando solo alla specifica (input attesi → output attesi), ignorando il codice interno; nel testing a scatola bianca (white-box) si guarda invece al codice per esercitarne tutti i cammini, misurando la copertura (coverage) raggiunta dai test. Poiché gli input possibili sono in genere infiniti, si usa il partizionamento in classi di equivalenza — si raggruppano gli input che il programma tratta nello stesso modo e se ne prova un rappresentante per classe — affiancato dall'analisi dei valori limite, che prova proprio i confini fra le classi (lo zero, il minimo, il massimo, la lista vuota), dove si annidano gli errori più frequenti. Conviene distinguere tre termini spesso confusi: lo sbaglio umano (error) introduce un difetto (fault) nel codice, che a sua volta può provocare un malfunzionamento (failure) osservabile; il debugging risale dal failure al fault. La programmazione difensiva contrasta i difetti a monte: si inseriscono asserzioni (assert) che verificano invarianti e precondizioni e fanno fallire subito, in modo evidente, il programma quando un'ipotesi è violata, anziché lasciarlo proseguire producendo dati errati. Vale infine, come principio metodologico, il monito di Dijkstra: il testing può rivelare la presenza di errori, mai dimostrarne l'assenza — solo una dimostrazione formale di correttezza potrebbe garantirla.