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
