Ada Lovelace’s aantekeningen over de Analytical Engine beschreven een herhaalbaar algoritme. Ontdek hoe haar vroege ideeën aansluiten bij modern programmaontwerp en denken.
Je kent waarschijnlijk de korte versie: Ada Lovelace schreef “het eerste algoritme”, een reeks instructies bedoeld voor Charles Babbage’s Analytical Engine. Mensen verwijzen er nog altijd naar omdat het een vroeg en verrassend duidelijk voorbeeld is van wat we nu programmeren noemen—een doel opdelen in precieze stappen die een machine kan volgen.
Dit artikel probeert de tandwielen van de Engine niet te reconstrueren of elk historisch feit tot in detail te bewijzen. In plaats daarvan richt het zich op de programmeerideeën in Lovelace’s werk: hoe je een wiskundig probleem uitvoerbaar maakt, hoe je data representeert, en hoe je een procedure zo communiceert dat iemand anders (of iets anders) die kan uitvoeren.
Lovelace’s beroemde “Notes” lezen als een brug tussen wiskunde en softwareontwerp. Ook al was de machine grotendeels hypothetisch, de manier van denken is herkenbaar voor iedereen die ooit heeft geprobeerd een computer iets betrouwbaar te laten doen.
Daar letten we op tijdens het lezen:
Het doel is eenvoudig: zie Lovelace’s “eerste algoritme” minder als een museumstuk en meer als een vroeg template voor computationeel denken dat nog steeds weerspiegelt hoe we vandaag programma’s ontwerpen.
Augusta Ada King, Countess of Lovelace—beter bekend als Ada Lovelace—groeide op op een kruispunt van poëzie en wiskunde. Haar moeder moedigde serieus studeren aan, en Ada werd snel deel van een kleine kring van vooraanstaande wetenschappers en denkers. Ze was geen eenzame genie die in isolatie werkte; ze was een begaafde samenwerkster die uitzonderlijk heldere vragen stelde over wat machines kunnen betekenen, niet alleen wat ze kunnen doen.
Charles Babbage was al beroemd vanwege zijn plannen voor mechanische berekeningen toen Ada hem ontmoette. Babbage kon hardware in zijn hoofd ontwerpen: tandwielen, assen en telwielen gerangschikt tot een systeem. Ada had daarentegen een talent voor uitleggen—complexe technische ideeën omzetten in gestructureerde, communiceerbare concepten.
Hun samenwerking werkte omdat hun sterke punten anders waren. Babbage duwde de technische visie vooruit; Ada duwde de conceptuele visie vooruit, vooral het idee dat een machine een vooraf ontworpen volgorde van bewerkingen kan volgen.
Babbage’s Analytical Engine was niet zomaar een betere rekenmachine. Op papier beschreef hij een general-purpose machine: een apparaat dat waarden kan opslaan, bewerkingen kan uitvoeren en een gepland stappenplan stap voor stap kan uitvoeren. Zie het als een vroeg blauwdruk voor wat we nu een programmeerbare computer noemen—ook al werd het in hun leven nooit voltooid.
De jaren 1840 waren een moment waarop wiskunde, industrie en automatisering elkaar begonnen te overlappen. Mensen verlangden naar betrouwbare methoden—tabellen, formules en herhaalbare procedures—omdat fouten duur waren en de wetenschap snel ging. In die context was Ada’s interesse in “hoe een machine te instrueren” geen curiositeit. Het was een tijdige reactie op een groeiende behoefte: menselijke redenering omzetten in herhaalbare, controleerbare processen.
Voordat Ada Lovelace een algoritme kon beschrijven, moest er een machine zijn die het waard was om “geprogrammeerd” te worden. Charles Babbage’s Analytical Engine werd bedacht als een general-purpose rekenmachine: geen apparaat voor één specifieke formule, maar een machine die zodanig ingesteld kon worden dat hij veel verschillende reeksen bewerkingen uitvoerde.
Het kernidee is eenvoudig: als je een probleem kunt opdelen in kleine rekenstappen (optellen, aftrekken, vermenigvuldigen, delen), zou een machine die stappen betrouwbaar moeten kunnen uitvoeren, in de juiste volgorde, zo vaak als nodig.
Dat is de sprong van een eenmalige berekening naar een herbruikbare methode.
Babbage beschreef twee hoofdcomponenten:
Voor input en output was de Engine ontworpen om instructies en data te ontvangen via ponskaarten (geïnspireerd door weefgetouwen), en om resultaten in een voor mensen bruikbare vorm te produceren—geprint of anderszins vastgelegd.
Als je die ideeën op vandaag toepast:
Daarom is de Analytical Engine belangrijk: hij schetst dezelfde scheiding waarop we nog steeds vertrouwen—hardware die stappen uitvoert, en programma’s die definiëren welke stappen uitgevoerd worden.
Als men het heeft over Ada Lovelace en het eerste algoritme, wijzen ze vaak op een specifieke set aanvullingen: de “Notes” die ze toevoegde aan haar Engelse vertaling van Luigi Menabrea’s artikel over Charles Babbage’s Analytical Engine.
Menabrea beschreef het concept van de machine. Lovelace ging verder: zij behandelde de Engine als iets dat je instructies kon geven—niet alleen iets om te bewonderen. Die verschuiving is waarom die Notes zo belangrijk zijn in de programmeergeschiedenis. Ze lezen als vroeg computationeel denken: een doel opdelen in precieze stappen, representaties kiezen, en anticiperen op hoe een mechanisme die stappen zal volgen.
Lovelace’s Notes leggen uit wat wij nu programmaontwerp zouden noemen. Ze beschrijft de onderdelen van de Engine (zoals een geheugenstore en een verwerkende “mill”) in termen van hoe bewerkingen geordend en gecontroleerd kunnen worden. Het centrale idee is simpel maar diepgaand: als de Analytical Engine bewerkingen in een bepaalde volgorde op gedefinieerde symbolen kan uitvoeren, dan moet het “hoe” opgeschreven worden in een vorm die de machine kan uitvoeren.
Hier begint haar werk te lijken op modern programmeren. Het is niet alleen theorie; het is methode.
Belangrijk is dat de Notes een uitgewerkt voorbeeld bevatten in de vorm van een tabel met stappen. Die legt regel voor regel vast wat de machine moet doen—welke waarden waar staan, welke bewerking daarna komt en waar resultaten worden opgeslagen.
Dat tabelformaat is een voorouder van de hedendaagse pseudocode, flowcharts en instructieschema’s: een expliciet, controleerbaar plan dat je kunt volgen zonder te gissen. Of je ooit een Analytical Engine bouwt of niet, de gewoonte die het leert—een idee omzetten in een uitvoerbare volgorde—is nog steeds de kern van het schrijven van software.
Een algoritme, in gewone taal, is een herhaalbare methode: een reeks duidelijke stappen die betrouwbaar van een beginpunt naar een antwoord leiden. Het is als een recept dat niet op intuïtie vertrouwt—als je de stappen volgt, zou je elke keer hetzelfde resultaat moeten krijgen.
Ada Lovelace’s beroemde voorbeeldalgoritme had als doel Bernoulli-getallen te berekenen—een reeks waarden die in veel delen van de wiskunde voorkomt (bijvoorbeeld in formules voor sommen als 1 + 2 + … + n, en in delen van de calculus). Je hoeft de theorie erachter niet te kennen om te waarderen waarom het een goed testgeval is voor een vroege rekenmachine.
Ze zijn uitdagend op de juiste manier:
Met andere woorden: het is complex genoeg om te bewijzen dat de machine een gestructureerde methode kan volgen, maar ordelijk genoeg om als stappen op te schrijven.
In de kern heeft het algoritme een vertrouwde structuur die we nog steeds in programma’s gebruiken:
Zo bekeken wees Lovelace niet alleen op het berekenen van een getal—ze toonde hoe je een meerstapsberekening organiseert zodat een machine die kan uitvoeren zonder te moeten raden.
Als men het over Lovelace’s Bernoulli-algoritme heeft, ligt de nadruk vaak op het resultaat (“een vroeg programma”) in plaats van op het ontwerpproces dat de stappen betrouwbaar maakt. De echte prestatie is niet alleen het opsommen van bewerkingen—het is ze zo vormgeven dat een machine ze zonder improvisatie kan volgen.
In plaats van “bereken Bernoulli-getallen” als één taak te behandelen, deelt de Notes het op in kleinere onderdelen die herhaalbaar en controleerbaar zijn: bereken tussenwaarden, combineer ze volgens een specifieke formule, noteer resultaten en ga dan naar het volgende geval.
Die decompositie is belangrijk omdat elke subtak afzonderlijk gevalideerd kan worden. Als een output verkeerd lijkt, debug je niet "het hele algoritme"; je inspecteert één stuk.
Een mechanische computer houdt niets "in gedachten". Elke waarde die later nodig is moet ergens worden opgeslagen, en de Notes zijn daar zorgvuldig over. Sommige getallen zijn tijdelijke werkwaarden; andere zijn definitieve resultaten die bewaard moeten blijven voor latere stappen.
Dit is een vroege vorm van nadenken over programmastatus:
De volgorde van bewerkingen is een veiligheidsmaatregel. Bepaalde berekeningen moeten vóór andere gebeuren, niet uit elegantie, maar om te voorkomen dat je een onvoorbereide waarde gebruikt of per ongeluk iets overschrijft dat later nodig is.
In moderne termen ontwerpt Lovelace controleflow zodat het programma een duidelijk pad heeft: doe A, dan B, dan C—omdat B eerst doen stilletjes het verkeerde antwoord zou opleveren.
Een van de meest “moderne” ideeën in Lovelace’s stapentabel is herhaling: dezelfde reeks instructies telkens opnieuw uitvoeren, niet omdat je vastzit, maar omdat herhalen de snelste weg naar een resultaat is.
Herhaling in een programma betekent: volg een klein recept van stappen, controleer of je klaar bent, en zo niet, voer hetzelfde recept opnieuw uit. Het cruciale is dat iets verandert elke keer—vaak een teller, een positie in een tabel of de waarde die je opbouwt—zodat het programma naar een finishlijn beweegt.
In Lovelace’s notatie zie je dit als een gestructureerde terugkeer naar eerdere stappen. In plaats van identieke instructies veelvuldig te herschrijven, beschrijft ze een patroon en geeft aan wanneer je moet terugkeren. Dat is het zaadje van wat we nu iteratie noemen.
Als je code hebt geschreven, ken je dit patroon als een for-lus ("herhaal dit N keer") of een while-lus ("herhaal totdat een conditie waar is"). Haar tabel impliceert ook bekende lus-ingrediënten:
Stel dat je de som van 1 tot en met 5 wilt.
total = 0i = 1i bij totali met 1i nog 5 of minder is, herhaal de tel-en-verhoog stappenDit is iteratie in gewone termen: een kleine lus die een teller bijwerkt en een resultaat ophoopt. Lovelace’s bijdrage was niet alleen wat ze berekende—ze liet zien dat een herhalingsstructuur duidelijk op papier te zetten is zodat een machine (en toekomstige mensen) die betrouwbaar kan uitvoeren.
Een procedure kan perfect logisch zijn in je hoofd en toch onmogelijk voor een machine—of een andere persoon—om te volgen zonder een manier om veranderende hoeveelheden aan te duiden. Daar komen variabelen en notatie om de hoek kijken.
Denk aan een variabele als een gelabeld doosje op een bureau. Het label blijft hetzelfde, maar de inhoud kan veranderen terwijl je werkt.
Als je een reeks berekent, heb je misschien:
Zonder die doosjes moet je alles in lange zinnen beschrijven (“neem het getal dat je twee stappen geleden berekende…”), wat snel tot een warboel leidt.
In Lovelace’s Notes zijn de symbolen en labels er niet om formeel te lijken—ze zijn er om het proces uitvoerbaar te maken. Duidelijke notatie beantwoordt praktische vragen:
Als procedures lang worden, voorkomen deze kleine verduidelijkingen de meest voorkomende fout: het verwarren van sterk gelijkende hoeveelheden.
Goede variabelennamen zijn nog steeds een van de goedkoopste manieren om fouten te verminderen. Vergelijk x1, x2, x3 met current_sum, term_index en next_term: de tweede set vertelt waarvoor de doosjes bedoeld zijn.
Types voegen een extra laag veiligheid toe. Beslissen of iets een integer, een decimaal, een lijst of een record is, is alsof je het juiste soort container kiest—sommige fouten worden onmogelijk, of in ieder geval eerder op te sporen.
Variabelen en notatie veranderen “een slim idee” in stappen die herhaalbaar zijn en correct door iedereen uitgevoerd kunnen worden (inclusief een machine).
Abstractie betekent je richten op wat belangrijk is en bewust details verbergen die er niet toe doen. Het is het verschil tussen zeggen “sorteer deze lijst” en elke ruil en vergelijking met de hand beschrijven. Lovelace’s Notes tonen deze neiging vroeg: ze willen een methode communiceren zonder de lezer te dwingen te verzanden in de mechanische details van de engine.
Een opvallend kenmerk van de Notes is hoe ze de kernideeën onafhankelijk houden van de fysieke acties van de machine. De Analytical Engine heeft zijn eigen "hoe" (tandwielen, store, mill), maar de Notes benadrukken het "wat": de reeks operaties die nodig zijn om een resultaat te bereiken.
Die scheiding is het zaad van wat we nu softwareontwerp noemen:
Als je de methode kunt beschrijven zonder de machine steeds opnieuw uit te leggen, behandel je berekening al als iets draagbaars—geschikt om op andere hardware of door andere mensen opnieuw te implementeren.
De stap-voor-stap tabellen in de Notes lijken op vroege “procedures”: een gedefinieerde reeks stappen die opnieuw gevolgd kan worden. Moderne code formaliseert dit als functies, modules en herbruikbare componenten.
Een goede functie doet wat Lovelace’s presentatie ook doet:
Daarom gaat abstractie niet over vaagheid—het gaat over bruikbaarheid. Hergebruik volgt vanzelf: als een methode duidelijk is uitgedrukt, kun je die opnieuw aanroepen in een nieuwe context, combineren met andere methoden en grotere systemen bouwen zonder te verdrinken in details.
Ada Lovelace beschreef niet alleen wat de Analytical Engine zou kunnen doen—ze liet zien hoe je een procedure ondubbelzinnig maakt voor een ander (of een machine) om te volgen. Dat is de stille kracht van haar Notes: ze behandelen uitleggen als onderdeel van het werk, niet als versiering.
Een reden dat haar presentatie nog modern aanvoelt, is het gebruik van gestructureerde stap-voor-stap tabellen. Een tabel dwingt beslissingen af die vage proza kan verbergen:
Dat vermindert ambiguïteit op dezelfde manier als pseudocode dat nu doet. Je kunt een alinea lezen en denken dat je het begrijpt—tot je het daadwerkelijk probeert uit te voeren. Een stapentabel maakt het “uitvoeringspad” zichtbaar, precies wat goede programmadocumentatie nastreeft.
Lovelace’s Notes combineren drie dingen die we nog steeds samen proberen te houden:
Waarvoor het programma bedoeld is (intentie)
Hoe het werkt (de procedure)
Hoe je de notatie interpreteert (de interface—namen, symbolen, aannames)
Dat komt netjes overeen met moderne comments, docstrings en READMEs. Een README legt doel en context uit. Inline comments verduidelijken lastige stappen. Docstrings definiëren inputs/outputs en randgevallen. Als één van deze ontbreekt, moeten gebruikers gissen—and gissen is waar bugs ontstaan.
Als je een proces documenteert (code of niet), schrijf alsof iemand het zonder jou zal reproduceren:
Dat is geen extra werk—het is hoe een methode herbruikbaar wordt.
Ada Lovelace wordt vaak geïntroduceerd met het gedurfde label: “de eerste programmeur.” Dat is een handige verkorting, maar het kan ook een rijker verhaal verarmen. Het debat gaat niet alleen over eer—het gaat over wat we bedoelen met programma, computer en auteurschap.
Als “programmeur” iemand is die instructies schreef bedoeld voor een general-purpose machine, dan heeft Lovelace een sterke claim. In haar Notes over de Analytical Engine beschreef ze een stap-voor-stap methode om Bernoulli-getallen te genereren—eigelijk een plan voor hoe de Engine een niet-triviale berekening zou kunnen uitvoeren.
Maar historici discussiëren over het etiket omdat:
Het is belangrijk om een rekenkundig idee scheiden van het bouwen van een werkende computer. Babbage’s grote bijdrage was architectonisch: een voorgestelde machine met geheugen (“store”), een processor (“mill”) en controle via ponskaarten. Lovelace’s bijdrage was interpretatief en expressief: zij verduidelijkte wat zo’n machine kon representeren en hoe een procedure opgeschreven kon worden zodat de machine die kon volgen.
Een programma houdt niet op een programma te zijn omdat de hardware nooit verscheen. In moderne termen is het alsof je software schrijft voor een platform dat nog theoretisch is—of een algoritme specificeert voordat de chip bestaat.
Een respectvolle manier om over dit tijdperk te spreken is het als een samenwerking tussen rollen te zien:
Wat we met zekerheid kunnen zeggen: Lovelace’s Notes hielpen definiëren wat programmeren is—niet louter berekenen, maar het zorgvuldig uitdrukken van een proces dat een machine kan uitvoeren.
Lovelace’s Notes zijn relevant omdat ze laten zien hoe te denken wanneer je een idee in een machine-uitvoerbaar plan verandert. Zelfs als je nooit ponskaarten of mechanische tandwielen aanraakt, passen de kernlessen nog steeds goed op modern programmaontwerp: geef het werk een duidelijke structuur, benoem dingen zorgvuldig, gebruik herhaling doelbewust en bouw herbruikbare onderdelen.
Structuur wint van cleverheid. Een programma is makkelijker te bouwen en te onderhouden als het in stappen met duidelijke doelen is opgesplitst. Lovelace’s aanpak spoort aan om eerst de vorm van de oplossing te ontwerpen voordat je in details duikt.
Duidelijkheid is een feature. Haar tabellen en uitleg waren geen versiering—ze waren onderdeel van het programma. Wanneer jouw toekomstige zelf (of een teamgenoot) de logica snel kan volgen, wordt het programma betrouwbaarder.
Iteratie is een tool, geen truc. Herhaling (lussen) is hoe je een methode opschaalt. Het sleutelidee is: definieer wat herhaalt, wat elk keer verandert en wanneer het stopt.
Abstractie maakt hergebruik mogelijk. Als een reeks stappen eenmaal werkt, moet je die met verschillende inputs kunnen hergebruiken. Dat is het begin van functies, modules en libraries.
Als je ooit een “bouw het door het te beschrijven” workflow hebt gebruikt—eerst eisen schrijven, het plan itereren en dan werkende software genereren—heb je al het spirit van Lovelace’s Notes herhaald: maak de procedure expliciet, houd status helder en documenteer aannames zodat uitvoering herhaalbaar is.
Dat is een van de redenen waarom platforms voor vibe-coding zoals Koder.ai natuurlijk in dit verhaal passen. Koder.ai laat je web-, backend- en mobiele applicaties maken via een chatinterface, maar dezelfde fundamenten gelden: je krijgt betere resultaten als je inputs/outputs specificeert, namen consistent gebruikt en vraagt om stapsgewijze structuur (planning mode kan helpen de “Notes” vast te leggen vóór je code genereert of verandert). De tooling is nieuw; de discipline niet.
Gebruik deze korte rondgang voordat je begint met coderen—or wanneer je iets debugt dat rommelig voelt:
Als je de “notes-first” stijl van programmaontwerp wilt versterken, helpen de volgende bronnen:
Samen veranderen deze gewoonten programmeren van “laat het werken” naar “maak het begrijpelijk”—dezelfde verschuiving waar Lovelace’s Notes al op wezen.
Ada Lovelace’s “eerste algoritme” is een stapsgewijze procedure (gepresenteerd in haar Notes) bedoeld om te worden uitgevoerd door Charles Babbage’s Analytical Engine. Het is beroemd omdat het berekening behandelt als een geplande reeks bewerkingen op opgeslagen waarden, wat sterk lijkt op modern programmeren, zelfs al werd de machine niet voltooid.
Het artikel richt zich op de programmeergedachten in Lovelace’s werk—hoe je een methode zo uitdrukt dat ze uitvoerbaar, controleerbaar en begrijpelijk is—en niet op het reconstrueren van de hardware van de Engine of het beslechten van elke historische discussie.
De Analytical Engine was een voorgestelde general-purpose machine die bedoeld was om:
Die architectuur is belangrijk omdat ze hardware die uitvoert scheidt van programma’s die bepalen welke stappen worden uitgevoerd—dezelfde scheiding waar moderne computers op steunen.
Bernoulli-getallen zijn een reeks die in verschillende wiskundige formules voorkomt. Ze vormen een goed voorbeeld omdat elk nieuw getal afhankelijk is van eerdere waarden, wat meerdere bewerkingen, tussenopslag en herhaalbare stappen vereist—precies het soort gestructureerd werk dat je wilt testen op een programmeerbare machine.
Een stapentabel dwingt precisie af. Hij laat je specificeren:
Daarom lijkt het op moderne pseudocode en helpt het anderen de procedure "uit te voeren" zonder te moeten raden.
Herhaling is de vroege vorm van iteratie: je definieert een klein setje stappen, verandert iets bij elke doorgang (zoals een teller of gedeeltelijke som) en stopt als aan een voorwaarde is voldaan. In moderne code vertaalt dat zich naar for/while-lussen met:
Omdat een machine niet op context of geheugen kan vertrouwen zoals mensen. Duidelijke, variabele-achtige labels laten je bijhouden:
Dat verkleint de meest voorkomende fout bij lange procedures: het verwarren van sterk gelijkende waarden.
Abstractie scheidt de methode (het algoritme) van de mechaniek (hoe de machine het uitvoert). Dat is het begin van herbruikbare componenten:
In moderne termen maakt dit functies en modules mogelijk die systemen schaalbaar maken.
Het etiket is onderwerp van debat omdat:
Veilig gezegd: haar Notes formuleren helder wat programmeren is: het schrijven van een ondubbelzinnige procedure die een machine zou kunnen volgen.
Gebruik deze snelle ontwerpcheck voordat je begint met coderen of wanneer je iets debugt dat rommelig aanvoelt:
Voor gerelateerde gidsen, zie /blog/how-to-write-better-requirements en /blog/pseudocode-examples.