Ada

La nascita di un linguaggio è a volte un processo del tutto privato, che avviene nella testa di un informatico scontento degli strumenti che ha a disposizione. Altre volte, invece, avviene in maniera molto più strutturata, come nel caso di Ada.

Anni '70: il Dipartimento della Difesa degli Stati Uniti d'America è uno dei più grossi produttori/consumatori di informatica, ma non ha delle linee guida rigide nella scelta di quale linguaggio debba essere usato per un determinato scopo o contesto. Così accade che all'interno del Dipartimento vengono usati non meno di 450 linguaggi diversi, con un evidente costo di manutenzione enorme, difficoltà di integrazione, rischi di errori.

Nel 1975 viene creato un gruppo di esperti che si propone di definire una volta per tutte le caratteristiche di un linguaggio sicuro, robusto, veloce abbastanza da poter essere utilizzato in tutti i progetti del Dipartimento. Purtroppo, sulla base dei requisiti definiti dal gruppo, nessuno dei linguaggi esistenti viene giudicato soddisfacente.

A questo punto, le specifiche diventano una richiesta pubblica e nel 1978 tre imprese informatiche (Intermetrics, Honeywell Bull e Softech) propongono ognuna la sua soluzione. Vince la proposta di Honeywell Bull, guidata da Jean Ichbiah, a cui viene dato il nome di Ada in onore di Ada Lovelace. L'omaggio non finisce qui: la data ufficiale di rilascio del manuale è fissata al 10 Dicembre, che è la data di nascita di Ada, e il codice interno è MIL-STD-1815, che è l'anno di nascita di Ada.

Ada è in qualche modo un derivato di Pascal, con ancora più attenzione alla robustezza e alla cattura degli errori al momento della compilazione, prima dell'esecuzione. Anche in Ada i termini del linguaggio sono ripresi dall'inglese standard (if, then, else, begin, end, procedure, with...), con pochissimi simboli tipografici speciali: esattamente l'opposto di APL. Non soltanto è obbligatorio definire il tipo di una variabile, ma si possono definire nuovi tipi. Inoltre, Ada è uno dei primi linguaggi a permettere la "concorrenza", che significa che si possono definire processi (detti "task") che verranno eseguiti parallelamente e non uno dopo l'altro.

Quello che segue è un esempio di codice Ada tratto dalla pagina Wikipedia in inglese:

    with Ada.Text_IO; use Ada.Text_IO;

    procedure Traffic is
    
       type Airplane_ID is range 1..10;             -- 10 airplanes
    
       task type Airplane (ID: Airplane_ID);        -- task representing airplanes, with ID as initialisation parameter
       type Airplane_Access is access Airplane;     -- reference type to Airplane
    
       protected type Runway is                     -- the shared runway (protected to allow concurrent access)
          entry Assign_Aircraft (ID: Airplane_ID);  -- all entries are guaranteed mutually exclusive
          entry Cleared_Runway (ID: Airplane_ID);
          entry Wait_For_Clear;
       private
          Clear: Boolean := True;                   -- protected private data - generally more than only a flag...
       end Runway;
       type Runway_Access is access all Runway;
    
       -- the air traffic controller task takes requests for takeoff and landing
       task type Controller (My_Runway: Runway_Access) is
          -- task entries for synchronous message passing
          entry Request_Takeoff (ID: in Airplane_ID; Takeoff: out Runway_Access);
          entry Request_Approach(ID: in Airplane_ID; Approach: out Runway_Access);
       end Controller;
    
       --  allocation of instances
       Runway1    : aliased Runway;              -- instantiate a runway
       Controller1: Controller (Runway1'Access); -- and a controller to manage it

Grazie a queste caratteristiche, Ada è usato soprattutto in contesti complessi dove un errore sarebbe gravissimo, come la gestione di aerei e treni ad alta velocità.

Lo stesso tipo di esigenza ha condotto allo sviluppo di SPARK_(programming_language), un linguaggio derivato da Ada (o meglio: da un sottoinsieme del linguaggio) a cui aggiunge il concetto di "contratto": per ogni funzione viene specificato quali sono i limiti entro i quali deve operare - per esempio, quali variabili può utilizzare.

La vita di Ada (il linguaggio) non è stata semplice e ha sofferto proprio del suo essere un linguaggio "ufficiale": per alcuni anni la scrittura di codice sorgente all'interno del Dipartimento della Difesa (e per un breve periodo anche della NATO) era obbligatoriamente in Ada. Inoltre i primi compilatori erano enormi e lentissimi. Insomma, un ambiente pesante e poco amichevole, lontanissimo dai tools amati dai programmatori indipendenti.

Malgrado questo, Ada continua ad avere una piccola ma agguerrita comunità di supporto, come Ada Resource Association.