Ada (linguaggio di programmazione)

Da Wikipedia, l'enciclopedia libera.
(Reindirizzamento da Ada (linguaggio))
ADA
Autore MIL-STD-1815/Ada 83: Jean Ichbiah
  • Ada 95: Tucker Taft
  • Ada 2005: Tucker Taft
Data di origine
Utilizzo
Paradigmi
Tipizzazione
Estensioni comuni .adb .ads
Influenzato da ALGOL 68, Pascal, C++ (Ada 95), Smalltalk (Ada 95), Java (Ada 2005)
Ha influenzato C++, Eiffel, PL/SQL, VHDL, Ruby, Java, Seed7
Implementazione di riferimento
Sistema operativo Multi-piattaforma
Sito web [1]

Ada è un linguaggio di programmazione general purpose sviluppato verso la fine degli anni settanta su iniziativa del Dipartimento della Difesa (DOD) degli Stati Uniti. Sia le specifiche che lo sviluppo del linguaggio furono affidati a bandi di gara. Tra le 17 proposte inviate in seguito al bando indetto dal DOD, fu scelto nel 1979 il progetto di Jean Ichbiah, che all'epoca lavorava presso la CII Honeywell Bull. Le specifiche divennero uno standard ANSI nel 1983.

Il nome iniziale del linguaggio doveva essere DOD-1, ma venne in seguito cambiato in Ada in onore di Ada Lovelace, illustre matematica dei primi anni del XIX secolo, accreditata come la prima programmatrice della storia per aver sviluppato un algoritmo per il calcolo dei numeri di Bernoulli sulla macchina analitica di Charles Babbage.

Introduzione[modifica | modifica wikitesto]

Fin dalla prima stesura, Ada fu sottoposto a un processo continuo di revisione che ne ha migliorato ed estese le caratteristiche di linguaggio estremamente efficiente e sicuro. Nel 1995 la prima versione fu aggiornata e notevolmente modificata con la ratifica di secondo standard (ISO/IEC 8652:1995(E)). Un'ulteriore nuova versione dello standard internazionale è attesa a breve, anche se le novità, principalmente costituite da una libreria di "Containers" come le "Linked List" e le "Map" di oggetti, sono da tempo già implementate nei più avanzati compilatori come il GCC-4.x della FSF - Free Software Foundation e lo GNAT di AdaCore.

Come esempio non esaustivo a proposito del fatto che Ada supporta la progettazione di sistemi software "mission and safety critical", basti sapere, caso più unico che raro, che i compilatori per il linguaggio devono seguire un processo di certificazione che è esso stesso uno standard internazionale (ISO/IEC 18009 - Ada: Conformity Assessment of a Language Processor). Il cosiddetto "ACATS - Ada Conformity Assessment Test Suite" è una suite di test costruita secondo il suddetto standard ed è parte integrante del processo di certificazione svolto da laboratori autorizzati sotto l'autorità del Ada Compiler Assessment Authority (ACAA).

Ada rappresenta lo stato dell'arte dell'ingegneria del software, e unisce in una soluzione unica principi e tecniche provenienti da diversi paradigmi di programmazione, in particolare programmazione modulare, programmazione orientata agli oggetti, programmazione concorrente e programmazione distribuita.

Sebbene l'interesse del DOD vertesse principalmente sullo sviluppo di applicazioni militari, Ada è un linguaggio general-purpose, ovvero utilizzabile in qualsiasi dominio applicativo. L'origine militare del linguaggio si rivela però nella presenza di caratteristiche molto evolute in materia di sicurezza del codice; per questo motivo, il linguaggio viene ancora oggi usato in molti contesti in cui il corretto funzionamento del software è critico, come sistemi di controllo di velivoli, del traffico aereo e software aerospaziale[1][2] (ad esempio, il software di controllo della ISS è scritto in Ada[3]).

Caratteristiche[modifica | modifica wikitesto]

Ada eredita alcune caratteristiche stilistiche fondamentali da ALGOL, rispetto al quale aggiunge molte funzionalità basilari (come il sistema di tipi, i record, i puntatori o le enumerazioni, implementati in buona parte in stile Pascal) e funzionalità avanzate proprie dei moderni linguaggi di programmazione (polimorfismo, ereditarietà, eccezioni, tasking).

Il linguaggio fornisce un gran numero di controlli sia statici (a tempo di compilazione) sia dinamici (a runtime, disattivabili se si vuole massimizzare l'efficienza tramite il pragma Suppress,[4] o tramite switch specifici dei vari compilatori), che prevengono una ampia varietà di errori (uso errato dei parametri, errori di tipo, violazione di range e off-by-one). Sicurezza e affidabilità del codice sono infatti uno dei principali aspetti che hanno guidato lo sviluppo del linguaggio.[5]

"Hello, world!" in Ada[modifica | modifica wikitesto]

Un Hello world in Ada è il seguente:[6]

with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is
begin
  Put_Line("Hello, world!");
end Hello;

Sintassi[modifica | modifica wikitesto]

A differenza della maggior parte dei linguaggi di programmazione, Ada è insensibile alle maiuscole.[7] Le convenzioni stilistiche più comuni prevedono di scrivere le keyword del linguaggio interamente in minuscolo (o, meno comunemente, interamente in maiuscolo) e i nomi di tutti gli identificatori (tipi, variabili, subroutine, package etc.) in snake case con l'iniziale di ogni parola maiuscola. I commenti sono su singola linea, iniziati da un doppio trattino "--" e terminati dal ritorno a capo. Per gli identificatori e i commenti Ada supporta il set di caratteri ISO 10646, permettendo quindi di scrivere codice in caratteri non ASCII, e la dimensione massima consentita è legata all'implementazione (nelle implementazioni standard deve essere pari a non meno di 200 caratteri).[8]

La sintassi di Ada impiega pochi simboli, prediligendo l'uso di parole in lingua inglese. I simboli sono l'assegnazione ":=", gli operatori aritmetici elementari ("+", "-", "*", "/" e "**"), gli operatori di comparazione ("<", "<=", ">", ">=", "=", "/="), i due punti ":" per dichiarare il tipo di una variabile, la freccia "=>" negli aggregati, l'operatore di accesso ai campi ".", l'indicazione di range "..", il tick "'" per accedere agli attributi, il punto e virgola per terminare le istruzioni. L'istruzione nulla è costituita dalla keyword null terminata da punto e virgola, mentre una riga vuota terminata da punto e virgola non è valida. I restanti operatori sono implementati tramite keyword (and, or, rem, mod etc.).

Ada è un linguaggio strutturato e i blocchi sono delimitati da keyword. La chiusura del blocco contiene un riferimento o identificatore per capire immediatamente a quale apertura appartiene ed evitare confusione, impedendo inoltre potenziali dangling else o analoghi errori. Ad esempio, una subroutine contenente un ciclo for appare come:

procedure Example is
  X: array (Integer range 1..5) of Integer;
begin
  for I in X'Range loop
    X(I) := I;
  end loop;
end Example;

Parole riservate[modifica | modifica wikitesto]

Il linguaggio, in riferimento allo standard Ada 2012, ha 73 parole riservate:[9]

abort
abs
abstract
accept
access
aliased
all
and
array
at
begin
body
case
constant
declare
delay
delta
digits
do
else
elsif
end
entry
exception
exit
for
function
generic
goto
if
in
interface
is
limited
loop
mod
new
not
null
of
or
others
out
overriding
package
pragma
private
procedure
protected
raise
range
record
rem
renames
requeue
return
reverse
select
separate
some
subtype
synchronized
tagged
task
reminate
then
type
until
use
when
while
with
xor

Esiste un'omonimia tra le parole riservate access, delta, digits, mod e range e gli omonimi attributi, ma essendo gli attributi sempre preceduti da un apostrofo (detto tick) non esiste rischio di ambiguità.[10]

Sistema di tipi[modifica | modifica wikitesto]

Ada è un linguaggio fortemente tipato e typesafe.[11] A differenza del C e dei suoi derivati, in Ada non esistono keyword che identificano tipi primitivi, e tutti i tipi predefiniti sono definiti nella standard library. I tipi predefiniti fondamentali (come Integer, Float o Character) sono definiti nel package Standard, ma per massimizzare la portabilità è considerata buona pratica non usare direttamente i tipi predefiniti e definire invece i propri, anche per i tipi numerici più semplici.[12]

A differenza del C e dei suoi derivati, Ada non ammette conversioni di tipo implicite (tranne che per i tipi universali e gli access type anonimi)[13] e la conversione di tipo si effettua scrivendo il nome del tipo seguito dalla variabile da convertire tra parentesi[14], ad esempio:

procedure Conversion is
  X: Float := 2.9;
  Y: Integer;
begin
  Y := X;          -- illegale (assegna valore Float a variabile Integer)
  X := X + 1;      -- illegale (l'operatore + non è definito su tipi misti)
  X := X + 1.0;    -- legale
  Y := Integer(X); -- conversione di tipo (con arrotondamento): ora Y vale 3
end Conversion;

Il tipo di un letterale può essere indicato esplicitamente con una sintassi simile alla conversione, aggiungendo un tick prima della parentesi aperta. Questo è utile soprattutto in caso di ambiguità, quando uno stesso letterale (ad esempio una stringa, o un valore enumerativo) può riferirsi a tipi diversi.[15]

Package[modifica | modifica wikitesto]

La modularità del codice ad un livello più astratto rispetto alle subroutine (che in Ada sono di due tipi distinti: procedure e function) è ottenuta tramite i package. Il package è suddiviso in una specifica e in una implementazione, e la prima può essere compilata separatamente dalla seconda, facilitando i test nelle fasi iniziali di sviluppo. I package possono essere compilati separatamente; in caso di modifica all'implementazione di un package ma senza alterarne la specifica, eventuali altri package da esso dipendenti non necessitano di essere ricompilati.[16]

Memoria dinamica[modifica | modifica wikitesto]

La memoria dinamica (chiamata storage pool) è gestita ad alto livello ed è typesafe. Il linguaggio non fornisce puntatori flessibili come quelli del C (che sono una tra le principali fonti di bug, errori e vulnerabilità), ma utilizza dei riferimenti (detti access type) che conservano informazioni sull'accessibilità degli oggetti ai quali fanno riferimento e seguono precise regole di accessibilità, prevenendo il problema dei dangling pointer. La versatilità del linguaggio per applicazioni a basso livello è comunque garantita, grazie all'attributo 'Address e al package System, che permettono di manipolare indirizzi di memoria raw. L'interfaccia Interfaces.C.Pointers fornisce inoltre dei puntatori in stile C, utili quando si interfaccia una applicazione Ada con una in C.

La semantica del linguaggio permette la garbage collection, la cui presenza è però legata all'implementazione: solitamente è assente nei compilatori per le architetture native (in quanto può influire in maniera imprevedibile sul timing, e questo è un effetto deleterio nei sistemi real-time)[17] ma è talvolta presente per i compilatori che hanno come architettura target è la JVM.

Note[modifica | modifica wikitesto]

  1. ^ S. Tucker Taft e Florence Olsen, Ada helps churn out less-buggy code, Government Computer News, 30 giugno 1999, pp. 2–3. URL consultato il 14 settembre 2010.
  2. ^ Michael Feldman, Who's using Ada?, SIGAda Education Working Group.
  3. ^ Pulling strings 220 miles above Earth - The ISS software serves as the orbiting lab's central nervous system, Boeing. (archiviato il 23 aprile 2015).
  4. ^ Barnes (2014), p. 380.
  5. ^ Gary Dismukes, Gem #63: The Effect of Pragma Suppress su adacore.com. (archiviato il 28 luglio 2015).
  6. ^ Il programma, salvato nel file hello.adb, può essere compilato usando il compilatore GNAT con il comando gnatmake hello.adb
  7. ^ Fanno eccezione i letterali di tipo carattere o stringa.
  8. ^ Barnes (2014), p. 67.
  9. ^ Barnes (2014), p. 851.
  10. ^ Barnes (2014), p. 68.
  11. ^ Barnes (2014), p. 11.
  12. ^ Barnes (2014), p. 18.
  13. ^ Barnes (2014), p. 211.
  14. ^ Barnes (2014), p. 83.
  15. ^ Barnes (2014), p. 87.
  16. ^ Barnes (2014), p. 265-266.
  17. ^ Bruce Powel Douglass, Doing Hard Time: Developing Real-time Systems with UML, Objects, Frameworks, and Patterns, Addison-Wesley, 1999, p. 91, ISBN 978-0-201-49837-0.

Bibliografia[modifica | modifica wikitesto]

Altri progetti[modifica | modifica wikitesto]

Collegamenti esterni[modifica | modifica wikitesto]

Controllo di autorità GND: (DE4000430-2
informatica Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica