Cos'è Fortran e perché gira ancora sui supercomputer

Stai installando una libreria scientifica per Python e a un certo punto l'installazione si ferma chiedendo un "compilatore Fortran". Oppure un professore di fisica ti passa il codice di una simulazione e scopri che è scritto in un linguaggio che credevi estinto da decenni. In questo articolo trovi cos'è Fortran, perché è ancora al centro del calcolo scientifico e in quali casi (pochi) ha senso impararlo.

Cos'è Fortran

Fortran è uno dei primi linguaggi di programmazione ad alto livello, nato in IBM negli anni Cinquanta per permettere a scienziati e ingegneri di scrivere formule matematiche invece di istruzioni macchina, ed è ancora oggi uno dei linguaggi principali del calcolo ad alte prestazioni.

Il nome viene da FORmula TRANslation, traduzione di formule, e dice esattamente a cosa serviva. Prima di Fortran, calcolare una traiettoria significava scrivere a mano lunghe sequenze di istruzioni per la macchina. Con Fortran scrivevi qualcosa di molto vicino all'equazione, e il compilatore la traduceva in codice efficiente.

Quest'ultimo punto era la vera scommessa: all'epoca nessuno credeva che un programma generato da un compilatore potesse essere veloce quanto uno scritto a mano. Fortran lo dimostrò, e la velocità del codice prodotto è rimasta da allora la sua ragione di esistere.

Non è un linguaggio morto

Questa è la parte che sorprende di più. A differenza di tanti linguaggi della sua generazione, Fortran non vive solo nel codice legacy da mantenere: si scrive codice Fortran nuovo, oggi, per problemi di frontiera.

I settori dove lo trovi sono quelli in cui si risolvono equazioni enormi su griglie enormi:

• Meteorologia: molti modelli di previsione del tempo usati dai servizi meteorologici.
• Clima: i modelli che simulano atmosfera, oceani e ghiacci su scale di decenni.
• Fisica: simulazioni di plasmi, astrofisica, fisica nucleare e delle particelle.
• Fluidodinamica computazionale: aerodinamica, combustione, flussi in turbine e motori.
• Chimica computazionale: calcolo della struttura di molecole e materiali.

Il filo comune: codici che girano per giorni su supercomputer con migliaia di processori, dove guadagnare anche una piccola frazione di prestazioni significa risparmiare giorni di calcolo. In questo mondo, Fortran compete alla pari con C e C++, e spesso vince per semplicità.

Perché è ancora così veloce

La domanda naturale è: se C è altrettanto compilato e a basso livello, perché non riscrivere tutto in C? Le ragioni sono tre, e la seconda è la più interessante.

Gli array sono cittadini di prima classe

In Fortran le matrici multidimensionali sono un tipo nativo del linguaggio, non una libreria. Puoi operare su un'intera griglia con una sola istruzione:

program anomalie
  implicit none
  integer, parameter :: nx = 360, ny = 180
  real :: temp(nx, ny), media(nx, ny), anomalia(nx, ny)

  call random_number(temp)
  temp  = temp * 40.0 - 10.0     ! temperature casuali tra -10 e 30
  media = 15.0                   ! assegna 15 a tutte le celle

  anomalia = temp - media        ! sottrazione su tutta la griglia
  print *, "Anomalia massima:", maxval(anomalia)
  print *, "Celle sopra +10:", count(anomalia > 10.0)
end program anomalie

Niente cicli annidati, niente puntatori. anomalia = temp - media sottrae due matrici 360×180 elemento per elemento, e count(anomalia > 10.0) conta le celle che rispettano una condizione. Chi usa NumPy riconosce subito lo stile: in Fortran questo modo di ragionare per array interi esisteva già, direttamente nel linguaggio.

Il vantaggio non è solo estetico. Poiché il compilatore sa che stai lavorando su array interi, può organizzare le operazioni nel modo più efficiente per il processore.

Niente aliasing: il punto tecnico chiave

Immagina una funzione che riceve due array, a e b, e fa a(i) = a(i) + b(i) per ogni elemento. Il processore moderno sa fare questa operazione su più elementi contemporaneamente (si chiama vettorizzazione), ed è lì che si guadagna velocità.

C'è però un problema. E se a e b fossero lo stesso array, o due pezzi sovrapposti della stessa memoria? Allora scrivere in a cambierebbe b mentre lo stai leggendo, e fare le operazioni in blocco darebbe un risultato sbagliato. Due nomi diversi che puntano alla stessa memoria si chiamano alias.

In C il compilatore deve considerare questa possibilità, perché i puntatori possono puntare dove vogliono. Quindi, nel dubbio, rinuncia a parte delle ottimizzazioni e procede con prudenza.

In Fortran le regole del linguaggio stabiliscono che, se una funzione modifica un argomento, quell'argomento non deve sovrapporsi agli altri. È una responsabilità del programmatore, e in cambio il compilatore può dare per scontato che non ci siano alias e ottimizzare in modo aggressivo, senza controlli.

È come la differenza tra un magazziniere che deve ricontrollare ogni scaffale perché qualcuno potrebbe averlo spostato, e uno che ha la garanzia che nessuno tocca niente mentre lavora. Il secondo va molto più veloce. C ha introdotto in seguito la parola chiave restrict proprio per offrire la stessa garanzia, ma in Fortran è il comportamento predefinito.

Decenni di librerie validate

Il terzo motivo è la storia. Le librerie di algebra lineare BLAS (operazioni base su vettori e matrici) e LAPACK (sistemi di equazioni, autovalori, decomposizioni) sono nate in Fortran e sono state testate, corrette e verificate per decenni da tutta la comunità scientifica.

Queste librerie stanno sotto a moltissimo software che usi senza saperlo. NumPy e SciPy si appoggiano a implementazioni di BLAS e LAPACK per le operazioni sulle matrici, e parte di SciPy contiene ancora codice Fortran. Lo stesso vale per R e per MATLAB. Quando moltiplichi due matrici in Python, c'è una buona probabilità che il lavoro vero lo faccia un algoritmo nato in Fortran.

Riscrivere questo patrimonio non avrebbe senso: servirebbero anni solo per riottenere la stessa affidabilità numerica.

Il Fortran delle leggende e quello di oggi

Se ti hanno raccontato che il Fortran si scrive in maiuscolo, con le istruzioni che devono partire dalla settima colonna, ti hanno descritto il FORTRAN 77, figlio delle schede perforate:

      PROGRAM SOMMA
      REAL A(100)
      S = 0.0
      DO 10 I = 1, 100
         S = S + A(I)
   10 CONTINUE
      PRINT *, S
      END

Colonne fisse, etichette numeriche per chiudere i cicli, e soprattutto la tipizzazione implicita: le variabili che iniziano con le lettere da I a N sono intere, tutte le altre reali, senza bisogno di dichiararle. Una fonte inesauribile di bug.

Dallo standard Fortran 90 in poi il linguaggio è cambiato profondamente, con revisioni successive che hanno continuato ad aggiungere funzionalità:

FORTRAN 77	Fortran moderno
Formato a colonne fisse	Formato libero
Tipi impliciti	implicit none e dichiarazioni esplicite
Cicli con etichette numeriche	do ... end do
Nessuna modularità	Moduli, interfacce, tipi derivati
Solo calcolo sequenziale	Operazioni su array intere, coarray per il calcolo parallelo
Niente oggetti	Programmazione a oggetti supportata

Il codice nuovo si scrive in Fortran moderno, e si legge senza fatica. Quello vecchio esiste ancora in grandi quantità, e i compilatori attuali (come gfortran, parte di GCC) lo compilano senza problemi, anche mescolato al nuovo.

Quando non ha senso usarlo

Serve onestà: fuori dal calcolo scientifico e dall'HPC, Fortran non ha nessun senso.

• Non ha un ecosistema per il web, le interfacce grafiche, i database o le API.
• La gestione delle stringhe e dell'input/output è scomoda rispetto a qualsiasi linguaggio moderno.
• Gli strumenti (gestori di pacchetti, librerie di terze parti, editor) sono migliorati, ma restano lontani da quelli di Python o JavaScript.

Anche nel calcolo scientifico, molti progetti nuovi partono in Python con le parti pesanti in C++, oppure in Julia, nato esplicitamente per risolvere il cosiddetto "problema dei due linguaggi": prototipare in un linguaggio comodo e poi riscrivere tutto in un linguaggio veloce come Fortran o C.

Sul lato lavoro, le offerte che chiedono Fortran sono poche e concentrate in enti di ricerca, università, centri di calcolo, servizi meteorologici e alcune aziende di ingegneria (aerospazio, energia). Di solito Fortran non è la competenza principale richiesta: è uno strumento che accompagna una formazione in fisica, ingegneria, matematica o scienze del clima. Se non lavori in quei campi, non è un investimento sensato.

Errori comuni con Fortran

Dimenticare implicit none. Senza, una variabile scritta male (tempeatura invece di temperatura) viene creata al volo con un tipo deciso dalla prima lettera. Il programma compila e produce numeri sbagliati. Mettilo in ogni programma e in ogni modulo.

Scorrere le matrici nell'ordine sbagliato. Fortran memorizza le matrici per colonne (column-major), al contrario di C e di NumPy di default. Il ciclo interno deve scorrere il primo indice. Invertire l'ordine non dà errori, ma può rallentare il codice in modo drastico perché la memoria viene letta a salti.

Dimenticare che gli indici partono da 1. Chi arriva da C o Python scrive a(0) e legge fuori dall'array. Di default Fortran non controlla i limiti: attiva i controlli del compilatore (in gfortran, -fcheck=bounds) mentre sviluppi.

Mescolare precisioni senza accorgersene. Scrivere 0.1 invece di 0.1d0 o di una costante con il kind esplicito fa sì che un valore venga calcolato in precisione singola dentro un calcolo in doppia. Nei codici numerici lunghi l'errore si accumula.

Giudicarlo dal codice anni Settanta. Il FORTRAN 77 che trovi nei vecchi progetti non rappresenta il linguaggio attuale. Se devi modificarlo, valuta di modernizzarlo un pezzo alla volta invece di continuare nello stile antico.

In sintesi

Fortran è uno dei primi linguaggi ad alto livello, nato per tradurre formule matematiche in codice veloce, e quella missione non l'ha mai cambiata.

Non è un linguaggio morto: gira ancora su supercomputer per meteorologia, clima, fisica e fluidodinamica, e si scrive codice nuovo in quei campi.

La sua velocità ha ragioni tecniche precise: array multidimensionali nativi, regole che vietano l'aliasing e permettono al compilatore ottimizzazioni aggressive, e decenni di librerie numeriche come BLAS e LAPACK, che lavorano anche sotto a NumPy.

Fuori da quel territorio non ha senso, e le offerte di lavoro sono rare e legate alla ricerca: impararlo conviene se lavori o studi in ambito scientifico, non come scelta generica.

Se stai valutando cosa studiare, il confronto completo è in tutti i linguaggi di programmazione.