Bohm–Jacopini: la chiave della programmazione strutturata e il teorema che ha cambiato il software

Nel panorama della computazione, pochi teoremi hanno avuto un impatto così profondo sulla pratica quotidiana degli sviluppatori quanto il teorema di Bohm–Jacopini. Servendosi di tre costruzioni di controllo fondamentali — sequenza, selezione e iterazione — questo risultato mostra che qualsiasi programma, anche se originariamente scritto con goto o salti arbitrari, può essere riscritto in una forma strutturata. In italiano, spesso si sente dire “Bohm–Jacopini” o, meno correttamente, “Bohm e Jacopini”, ma la versione più diffusa e tecnicamente accurata è la forma con trattino: Bohm–Jacopini. In questo articolo esploreremo origini, contenuto, implicazioni e oggi l’eredità di quella teoria, offrendo anche esempi concreti e una visione critica utile per chi lavora con linguaggi moderni.

Origini e contesto storico di Bohm–Jacopini

I protagonisti: Bohm e Jacopini

Herbert Böhm? No, qui stiamo parlando di un contesto di informatica teorica: Corrado Böhm e Giuseppe Jacopini, due ricercatori che agli inizi degli anni ’60 si confrontarono con una domanda fondamentale per la programmazione. Böhm e Jacopini non proposero solo una curiosità accademica, ma un risultato che avrebbe influenzato in modo sostanziale la pratica di scrittura del codice. La loro collaborazione portò a una dimostrazione che andava oltre i linguaggi specifici: una teoria universale su come si possa strutturare la logica di controllo di un programma senza ricorrere all’uso indiscriminato del goto.

Il contesto della ricerca negli anni ’60

Negli anni ’60 la programmazione stava ancora scoprendo i principi di base della strutturazione del codice. Molti linguaggi dell’epoca consentivano salti non lineari e eterogenei del flusso di esecuzione; i programmatori spesso si ritrovavano a danzare tra etichette, salti e loop intricati. In quel contesto, l’idea di una programmazione “pulita” — priva di salti non strutturati — sembrava quasi una rivoluzione culturale quanto tecnica. È in questo ambiente che Bohm–Jacopini propongono una via per dimostrare che la complessità di un algoritmo non dipende dalla possibilità di saltare avanti e indietro, ma dalla capacità di descriverlo in modo chiaro e ordinato usando solo tre costrutti fondamentali.

La domanda chiave: è possibile eliminare goto?

La domanda che guidò la loro ricerca è semplice in apparenza: è davvero necessario utilizzare goto per esprimere qualunque calcolo? Oppure si può ridurre la logica di controllo a strutture ben definite che facilitino comprensione, verifica e manutenzione? La risposta, fornita dal teorema Bohm–Jacopini, è stata sorprendente: sì, è possibile. Ogni flusso di controllo che una macchina può eseguire si può riscrivere utilizzando solo tre costrutti: sequenza, selezione ed iterazione. Questo risultato fu un punto di svolta, aprendo la strada alla formalizzazione della programmazione strutturata e all’industria moderna della software engineering.

Il teorema di Bohm–Jacopini: contenuto e significato

Enunciato formale (semplificato)

In forma facilmente riassumibile, il teorema Bohm–Jacopini afferma che: qualsiasi programma computazionale definibile con costrutti di salto non strutturati può essere riscritto in modo equivalente utilizzando solo tre costrutti fondamentali — una semplice sequenza di comandi, una costruzione di selezione (condizionale) e un costrutto di iterazione (ciclo). In altre parole, i salti complessi e non lineari non sono necessari per esprimere la computazione; basta organizzare il flusso di esecuzione con strutture ben definite che impongano una gerarchia chiara e verificabile.

Dimostrazione intuitiva

La dimostrazione di Bohm–Jacopini è di carattere costruttivo. Partendo da un grafo di controllo che include etichette e salti, si può tradurre ogni cammino possibile in un unico schema strutturato. L’idea chiave è l’uso di segmenti di codice racchiusi che si ripetono o si esportano in strutture condizionali, anziché saltare da una parte all’altra del programma. Una versione comune del ragionamento mostra come i GoTo si possano sostituire con versioni equivalenti basate su strutture iterativi e sui rami condizionali, talvolta introducendo variabili di stato ausiliarie o controlli di loop annidati. L’effetto pratico è una trasformazione che conserva la semantica, ma cambia la forma del codice in qualcosa di più leggibile, mantenibile e analizzabile.

Relazione con l’idea di strutturazione del codice

Il teorema non è una mera curiosità teorica: è la pietra angolare della programmazione strutturata. L’idea è che una logica di controllo ben definita, composta da una combinazione di sequenza, selezione e iterazione, è sufficiente per modellare qualunque flusso di esecuzione. All’epoca la discussione era anche una risposta alla proliferazione di tecniche di programmazione non strutturate che rendevano i programmi difficili da capire. Il risultato di Bohm–Jacopini ha fornito una giustificazione teorica per promuovere pratiche di codifica più limpide, meno suscettibili ad errori e più facili da analizzare staticamente o formalmente.

Implicazioni pratiche per la programmazione strutturata

Costrutti di controllo: sequenza, selezione e iterazione

Il primo lascito pratico del teorema Bohm–Jacopini è la tripla di costrutti di controllo. La sequenza rappresenta l’esecuzione lineare dei comandi. La selezione consente di scegliere tra percorsi alternativi in base a una condizione, tipicamente tramite costrutti come if-then-else. L’iterazione permette di ripetere un blocco di istruzioni finché una condizione non è soddisfatta, usando while o for. Insieme, questi tre elementi danno una grammatica completa per descrivere la maggior parte dei problemi computazionali. L’adozione di questa grammatica ha reso l’analisi, la verifica e la manutenzione dei software molto più agevoli, contribuendo alla diffusione di pratiche di programmazione strutturata in tutto il settore.

Esempi concreti: convertire programmi con goto

Per mostrare l’applicazione concreta, consideriamo un frammento che usa goto per gestire un ciclo: un’etichetta inizio, salti condizionali e un salto non lineare. Applicando la logica di Bohm–Jacopini, si può trasformare quel frammento in una forma con strutture di controllo ben definite. Si sostituiscono i salti con:
– una sezione di codice sequenziale,
– una o più condizioni che guidano l’esecuzione verso i rami corretti (if/else),
– eventuali cicli while o loop finché la logica non esita. Questa riscrittura non cambia la funzione del programma, ma migliora notevolmente leggibilità e testabilità, fattori chiave nel ciclo di vita del software.

Impatto storico e teorico

L’effetto su Dijkstra e la filosofia della programmazione

Tra le figure rivoluzionarie dell’informatica, Edsger Dijkstra ha promosso l’idea che il goto è dannoso per la qualità del software, sostenendo che la strutturazione del flusso di controllo è essenziale per la comprensione. Il teorema Bohm–Jacopini fornisce una base teorica solida a questa filosofia, dimostrando che la complessità non deriva dai salti in sé, ma da come si organizza il controllo. L’eredità di questa argomentazione ha accompagnato decenni di studi su programmazione strutturata, metodologie di sviluppo software e, più recentemente, su pratiche di programmazione sicura e verificata.

Critiche e limiti moderni: linguaggi funzionali, strutturazione e paradigmi imperativi

Non mancano le voci critiche. Con l’avvento di linguaggi funzionali e di approcci orientati agli oggetti, alcuni sostenitori hanno notato che la rigidità strutturata promessa dal teorema Einstein di Bohm–Jacopini non copre tutte le esigenze moderne, come la gestione di effetti collaterali, la concorrenza o i pattern di programmazione asincrona. Inoltre, i linguaggi contemporanei includono costrutti che, pur non essendo goto, si discostano dall’idea di blocchi strettamente strutturati (ad es. closure, continuità di flusso in ambienti concorrenti, gestione degli errori tramite eccezioni). In questo senso, Bohm–Jacopini rimane una pietra miliare, ma non l’ultima parola sull’architettura del controllo: serve un modello aggiornato che integri strutturazione e modularità in contesti complessi.

Bohm–Jacopini oggi: eredità e applicazioni

Nel mondo educativo

Insegnare la programmazione strutturata parte spesso dall’insegnamento di Bohm–Jacopini. Le lezioni introduttive mostrano agli studenti come scomporre un algoritmo in blocchi chiari, come gestire le condizioni e come progettare loop coerenti. L’idea di passare da flussi di controllo non strutturati a una grammatica di base aiuta a sviluppare buone pratiche di design del software fin dall’inizio, riducendo la propensione agli errori comuni associati ai salti disordinati.

In sistemi embedded e linguaggi moderni (C, Java, Python)

Nei sistemi embedded e nei linguaggi di uso quotidiano, la lezione di Bohm–Jacopini resta utile. Anche se i linguaggi moderni offrono meccanismi sofisticati per la gestione degli errori, la concisione di strutture di controllo pure e la capacità di tracciare flussi di esecuzione rimangono vantaggi concreti. In C, ad esempio, l’approccio strutturato predilige loop e costrutti condizionali chiari piuttosto che l’uso indiscriminato di goto. In Java e Python, l’adozione di strutture di controllo chiare facilita non solo la leggibilità, ma anche la manutenzione del codice e la verifica automatizzata.

Analisi statica e modellazione visiva

Un altro campo dove l’eredità di Bohm–Jacopini si sente è l’analisi statica e la modellazione visiva del flusso di controllo. Diagrammi di controllo, diagrammi di flusso e grafi di esecuzione si basano sull’idea di avere tre costrutti strutturali fondamentali. Questi strumenti aiutano i team a rilevare percorsi indesiderati, ridurre cicli nascosti e migliorare la testabilità. Anche nel contesto di strumenti di programmazione orientata agli oggetti o di linguaggi concorrenti, le lezioni tratte dal teorema rimangono utili per progettare sistemi robusti e affidabili.

Conclusione: perché Bohm–Jacopini resta rilevante

Bohm–Jacopini rappresenta una pietra miliare della storia della programmazione. Non solo ha fornito un fondamento teorico per la programmazione strutturata, ma ha anche influenzato pratiche, strumenti e workflow che definiscono la qualità del software ancora oggi. La lezione è chiara: la chiarezza e la prevedibilità del flusso di controllo sono alleati della manutenzione, della verifica e della scalabilità. Nel tempo, gli sviluppatori hanno arricchito questa base con nuovi modelli, ma la semantica di Bohm–Jacopini rimane una guida utile per scrivere codice che sia facile da capire, testare e evolvere.

• Il teorema Bohm–Jacopini dimostra che ogni programma può essere espresso con tre soli costrutti di controllo: sequenza, selezione e iterazione.
• È una base teorica per la programmazione strutturata, utile sia per l’insegnamento sia per la pratica professionale.
• La sua influenza si estende dalla teoria della computazione all’ingegneria del software, passando per l’analisi statica e la modellazione visiva del flusso di controllo.
• In contesti moderni, si integra con paradigmi contemporanei, ma continua a offrire una lente utile per valutare la leggibilità e la correttezza del codice.

In definitiva, Bohm–Jacopini non è solo un capitolo della storia della computazione, ma una bussola pratica che continua a orientare la scrittura di software chiaro, affidabile e manutenibile. Dalla teoria al codice, dall’aula al sistema embedded, la lezione resta attuale: i tre pilastri della logica di controllo — sequenza, selezione e iterazione — sono sufficienti a descrivere e gestire la complessità di qualunque algoritmo.