<-- Home



                        Waarom Ada?
                        ===========
                        2020-09-05


Waarom zou  je  in  een  archaïsche  programmeertaal  willen
werken?  Eentje die geassocieerd wordt met  Fortran,  Cobol,
bandplooibroeken en verstandige  leren  schoenen?   Aan  Ada
kleven  een  hoop  vooroordelen,  maar  onder   haar   lange
geschiedenis gaat een verrassend moderne taal schuil die  is
meegegroeid met de tijd en een  hoop  te  bieden  heeft  aan
programmeurs in de jaren twintig.

Ada werd ontworpen in de jaren zeventig in opdracht van  het
Amerikaanse ministerie van defensie (DoD).  Er  zweefden  in
die tijd zoveel verschillende talen rond bij  het  DoD  rond
dat het onwerkbaar werd en daarom groeide de wens om met een
gemeenschappelijke taal te gaan werken.  Na jaren soebatten,
vergaderen en het doornemen van voorstellen kreeg  het  plan
dat was ingediend  door  Honeywell  de  voorkeur.   Ada  was
geboren en kreeg in 1983 een formeel  stempel  met  een  ISO
standaard. In de jaren daarna groeide de populariteit van de
taal en werd  het  ook  buiten  het  militaire  domein  veel
toegepast in gebieden waar veiligheid en betrouwbaarheid van
essentieel  belang  waren:   de   luchtvaart,   ruimtevaart,
spoorwegsystemen en bij medische  toepassingen.   In  andere
sectoren was het korte tijd populair,  maar  het  werd  snel
ingehaald door andere talen en verdween langzamerhand op  de
achtergrond. Ada bleef echter niet stilstaan. In 1995, 2005
en 2012 werden vernieuwde ISO standaarden  gepubliceerd  met
toevoegingen die aansloten  bij  de  programmeerstijlen  die
toen  “en  vogue”  waren.   In  '95  werd  het   de   eerste
ISO-gecertificeerde taal met uitgebreide ondersteuning  voor
objectoriëntatie,  in  2005  werden  er  veel  verbeteringen
toegevoegd voor parallelle en realtime taken en in 2012 kwam
er ondersteuning voor contractgestuurd programmeren bij.  Op
het moment zijn vergadertijgers bezig met het ontwerpen  van
Ada 202x  die  ook  allerhande  hips  en  vernieuwends  moet
toevoegen zoals veilige pointers die  geïnspireerd  zijn  op
Rust.

Ada is kortom niet in de steentijd blijven hangen en als  je
een switch naar een nieuwe taal  overweegt,  omdat  de  oude
begint te vervelen of niet meer voldoet dan is het de moeite
waard om haar iets beter te bekijken.

Ada heeft de volgende eigenschappen waar ik erg gelukkig van
word:

- Het uitgangspunt van Ada is dat je er betrouwbare, veilige
  software mee moet kunnen bouwen  die  ook  nog  eens  goed
  presteert.  In de cultuur rond Ada tref je geen “move fast
  and break stuff”, maar meer een bedachtzame en zorgvuldige
  manier van werken.

- Ada heeft een sterk en  statisch  typesysteem.   Het  gaat
  echter  verder  dan  de  meeste  talen,  want  het   leunt
  aanmerkelijk minder op een handvol primitieve types die je
  kunt gebruiken.  Je kunt eigen types beschrijven,  en  ook
  restricties meegeven.  Je kunt bijvoorbeeld zeggen dat een
  type een natuurlijk getal moet voorstellen dat een  vooraf
  gedefinieerd bereik heeft.  Deze verfijnde aanpak  is  erg
  krachtig en wekt veel vertrouwen in de code die  je  ermee
  opbouwt.

- De syntax van Ada is gebaseerd op de  Algol/Pascal-familie
  van talen.  Dit is puur smaak natuurlijk, maar als  iemand
  met sterke Turbo Pascal roots word ik wel gelukkig van  de
  expliciete “begin” en “ends” in de  code,  in  plaats  van
  alle  accolades  die  je  bij  de  C-achtige  talen  ziet.

- Ada heeft geen garbage collector.  Geheugenbeheer gaat dus
  handmatig. In de ogen van veel moderne programmeurs is dit
  een deal breaker, maar het helpt bij de prestaties van  je
  programma's.  In tegenstelling tot bij C/C++ betekent  het
  ontbreken van een GC echter niet dat je maar de hele  tijd
  geheugen aan het alloceren en  het  bevrijden  bent.   Ada
  heeft  door   middel   van   het   “access”   type   ruime
  mogelijkheden om op een betrouwbare manier met geheugen om
  te gaan.   Daarnaast  is  het  mogelijk  om  objecten  van
  dynamische grootte op de stack  te  definiëren  waarna  ze
  automatisch verdwijnen als ze uit de scope raken.  Er zijn
  dus   ook    aanmerkelijk    minder    situaties    waarin
  geheugenbeheer een zorg is.

- Je kunt in Ada bij functies en procedures aangeven  of  je
  variabelen als input, output of beide wil gebruiken.  Hier
  heb je ook geen pointers voor nodig.

- Ada heeft in de taal zelf door  middel  van  “tasks”  hele
  goede ondersteuning voor parallel programmeren.   Je  kunt
  ook  objecten  aanmerken  als  “protected”,   wat   gemene
  problemen kan voorkomen zoals je die vaak tegenkomt als je
  met  meerdere  threads  dezelfde   data   wil   benaderen.

- Ada heeft vrij goede prestaties,  vergelijkbaar  met  C++.
  Het  heeft   ook   goede   ondersteuning   voor   embedded
  programmeren.  Als je dat wil kun je heel  specifiek  zijn
  over  geheugenlayout  en  de  hoeveelheid  bits   die   je
  variabelen innemen.   Dit  opent  ook  mogelijkheden  voor
  datageörienteerd programmeren zoals dat gebruikt wordt bij
  moderne game-ontwikkeling.

- Vanaf Ada 2012 kun je ook  contractgestuurd  programmeren.
  Je kunt pre- en postcondities definiëren  en  deze  worden
  automatisch gecheckt door de compiler.  Deze zijn ook  een
  belangrijk middel voor de ultraveilige  Spark  subset  van
  Ada.  Deze zustertaal van Ada wordt gebruikt voor  uiterst
  kritieke software en kan ook samenwerken met software  die
  formele  eigenschappen   van   je   code   kan   bewijzen.

- Ada heeft een levendige online gemeenschap en er zijn veel
  open source bibliotheken beschikbaar.  Het  blijft  echter
  een niche en veel van het echte  werk  gebeurt  achter  de
  schermen  bij  bedrijven  die  gesloten  software   maken.
  Desalniettemin wordt er veel gedeeld en is ook de leidende
  compiler (Gnat)  beschikbaar  als  vrije  en  open  source
  software.

- Er is geen standaard package manager beschikbaar voor Ada.
  Het is misschien maf om dit als voordeel te  noemen,  maar
  we  hebben  aan  de  NodeJS   wereld   gezien   waar   een
  wijdverbreid  ecosysteem  vol  packages   met   onderlinge
  afhankelijkheden  toe  kan  leiden.   Vaak  betekent   het
  toevoegen van een  afhankelijkheid  aan  een  package  het
  installeren van talloze. Al snel raak je dan het overzicht
  kwijt over  welke  software  nou  eigenlijk  jouw  project
  aansturen en voel je je al snel als een  kapitein  op  het
  topje van een drijvende ijsberg des doods.  Vergeef me  de
  hyperbool, maar ik geloof echt in het  beteugelen  van  je
  software en een populair package systeem  kan  dit  aardig
  dwarszitten. Als de taalcultuur niet een standaard package
  manager   voorschrijft   en   mensen   gewend   zijn    om
  afhankelijkheden handmatig te beheren, dan zal je nooit de
  explosie   van   complexiteit   zien   zoals   bij   Node.

Er   kleven   natuurlijk   ook   wat   nadelen   aan    Ada:

- Het Adawereldje blijft een  niche.   Eentje  die  al  lang
  bestaat en een  focus  op  veiligheid  en  betrouwbaarheid
  heeft, maar toch kan dit een nadeel zijn.  Er zijn  minder
  online bronnen beschikbaar met info over hoe  je  bepaalde
  dingen aanpakt en er zijn minder  softwarebibliotheken  te
  vinden voor alles wat je wil kunnen doen in je software en
  je niet per se zelf wil programmeren.

- Ada is een grote taal.  Als je Ada wil leren dan  betekent
  dit dat je je wat moet schrapzetten.  Ze is  gelukkig  wat
  minder schijnbaar lukraak en organisch gegroeid  dan  veel
  andere  talen,  maar  toch  kan   de   omvang   van   alle
  taalconstructen wat intimiderend zijn.

- De syntax zijn voor mensen die gehecht zijn aan het  typen
  van  accolades  nogal  teleurstellend.    Je   toetsenbord
  verslijt ook een stuk sneller dan  bij  de  meeste  andere
  talen, want Ada is nogal verbaal.  Het  leidende  argument
  binnen de Ada-scene is natuurlijk dat broncode vaker wordt
  gelezen dan geschreven en dat leesbaarheid  daarom  voorop
  moet staan. Mij is het persoonlijk om het even en ligt het
  meer aan smaak.

- Ada heeft toch wel een zweem van grootvaders  technologie.
  Hoezeer  er  ook  gemoderniseerd  is,  gebeurt  de  meeste
  Ada-ontwikkeling  toch  in  vrij  conservatieve  sectoren.
  Persoonlijk prefereer ik mijn technologie wat aan de saaie
  en  betrouwbare  kant,  maar  je   gaat   met   Ada   geen
  hipheidspunten scoren.  Je kunt dan beter afslaan richting
  Rust.  Die taal deelt veel van de waardes  van  Ada,  maar
  daarmee kun je aanmerkelijk de beter de blits maken op  de
  “socials”.

- Ada compilers  zijn  vrij  streng.   Met  de  Franse  slag
  programmeren zit er niet in.  Je wordt gedwongen exact  te
  zijn over wat je wil zeggen.  Hier loop je zeker  tegenaan
  als je met Spark gaat werken.   Voor  de  fans  van  Harry
  Potter: Ada  is  meer  een  professor  Anderling  dan  een
  Hagrid.

Ergo:

Ada is een interessante  moderne  programmeertaal  die  veel
probeert te doen om je  leven  als  programmeer  zo  prettig
mogelijk te maken.  Prettig betekent in deze  zin  wel  iets
meer het soort van verstandige prettig dat je  krijgt  nadat
je braaf je groentjes eet en iets minder van het soort Dukes
of Hazzard soort cowboyprettig, maar  laten  we  wel  wezen:
kwaliteit en betrouwbaarheid van onze software is ontzettend
belangrijk.  Onze leefwereld wordt bevolkt door steeds  meer
software en niet allemaal software van goede kwaliteit.  Ada
is geen panacea tegen slechte software, maar biedt wel  heel
veel  aanknopingspunten  om   goede   code   te   schrijven.

Ik ben geen evangelist en geloof dat het mogelijk  is  goede
software te maken in bijna elke programmeertaal.  Toch  denk
ik dat het gebruik van een taal als Ada enorm kan helpen. In
toekomstige blogberichten wil ik  een  aantal  eigenschappen
verder napluizen en ook verwijzen naar wat anderen  allemaal
voor   boeiende   dingen    over    Ada    gezegd    hebben.


-----------------------------------------------------------
                   Tags: Ada, Nederlands