06 mars 2025·8 min
Ada Lovelaces första algoritm och vad den lär oss idag
Ada Lovelaces anteckningar om Analytical Engine beskrev en upprepbar algoritm. Se hur hennes tidiga idéer kartläggs till modern programdesign och tänkande.
Ada Lovelaces anteckningar om Analytical Engine beskrev en upprepbar algoritm. Se hur hennes tidiga idéer kartläggs till modern programdesign och tänkande.
Du har förmodligen hört rubrikversionen: Ada Lovelace skrev “den första algoritmen”, en uppsättning instruktioner avsedd för Charles Babbage’s Analytical Engine. Folk hänvisar fortfarande till den eftersom den är ett tidigt, ovanligt klart exempel på det vi nu kallar programmering—att dela upp ett mål i precisa steg en maskin kan följa.
Den här artikeln försöker inte återskapa Engine:ns kugghjul eller bevisa varje historisk detalj bortom tvivel. I stället fokuserar den på de programmeringsidéer som finns i Lovelaces arbete: hur du omvandlar ett matematiskt problem till något exekverbart, hur du representerar data, och hur du kommunicerar en procedur så att någon annan (eller något annat) kan köra den.
Lovelaces berömda “Notes” läser som en bro mellan matematik och mjukvarudesign. Även om maskinen till stor del var hypotetisk, känns tänkandet igen för alla som försökt få en dator att göra något pålitligt.
Här är vad vi kommer hålla utkik efter:
I slutändan är målet enkelt: se Lovelaces “första algoritm” mindre som ett museiföremål och mer som en tidig mall för beräkningsmässigt tänkande som fortfarande speglar hur vi designar program idag.
Augusta Ada King, grevinna av Lovelace—bättre känd som Ada Lovelace—växte upp i ett skärningspunkt mellan poesi och matematik. Hennes mor uppmuntrade till rigorös studie, och Ada blev snabbt en del av en liten krets av framstående vetenskapsmän och tänkare. Hon var inte en ensam genii som arbetade i isolering; hon var en begåvad medarbetare som ställde ovanligt klara frågor om vad maskiner kunde betyda, inte bara vad de kunde göra.
Charles Babbage var redan känd för sina planer på mekanisk beräkning när Ada mötte honom. Babbage kunde designa hårdvara i huvudet: kugghjul, axlar och sifferhjul ordnade i ett system. Ada, å andra sidan, hade en talang för förklaring—att ta komplexa tekniska idéer och översätta dem till strukturerade, kommunicerbara koncept.
Deras relation fungerade eftersom deras styrkor var olika. Babbage drev den tekniska visionen framåt; Ada drev den konceptuella visionen, särskilt idén att en maskin kunde följa en sekvens av operationer som någon planerat i förväg.
Babbage’s Analytical Engine var inte bara en bättre räknemaskin. På papper beskrev den en allmän maskin: en som kunde lagra värden, utföra operationer och köra en planerad procedur steg för steg. Tänk på den som en tidig ritning för det vi nu kallar en programmerbar dator—även om den aldrig blev färdig under deras livstid.
1840-talet var en tid då matematik, industri och automation började överlappa. Människor var hungriga efter pålitliga metoder—tabeller, formler och upprepbara procedurer—eftersom fel var kostsamma och vetenskapen accelererade. I det sammanhanget var Adas intresse för “hur man instruerar en maskin” inte en nyfikenhet. Det var ett tidsenligt svar på ett växande behov: att göra mänskligt resonemang till upprepbara, kontrollerbara processer.
Innan Ada Lovelace kunde beskriva en algoritm måste det finnas en maskin värd att “programmera”. Charles Babbage’s Analytical Engine var tänkt som en allmän räknemaskin: inte en apparat för en viss formel, utan en maskin som kunde konfigureras för att utföra många olika sekvenser av operationer.
Kärnidéen var enkel: om du kan bryta ett problem i små aritmetiska steg (addera, subtrahera, multiplicera, dividera), borde en maskin kunna utföra de stegen pålitligt, i rätt ordning, så många gånger som behövs.
Det är språnget från en engångsberäkning till en återanvändbar metod.
Babbage beskrev två huvudkomponenter:
För in- och utdata var Engine designad för att ta instruktioner och data via hålkort (inspirerat av vävstolar) och att producera resultat i en form som en människa kan använda—tryckt eller på annat sätt registrerat.
Om du mappar dessa idéer till idag:
Det är därför Analytical Engine är viktig: den skissar samma separation som vi fortfarande litar på—hårdvara som kan exekvera steg, och program som definierar vilka steg som ska köras.
När folk pratar om Ada Lovelace och den första algoritmen pekar de ofta på en specifik uppsättning tillägg: de “Notes” hon fogade till sin engelska översättning av Luigi Menabreas artikel om Charles Babbage’s Analytical Engine.
Menabrea beskrev maskinens koncept. Lovelace gick längre: hon behandlade Engine som något man kunde instruera—inte bara beundra. Denna förskjutning är varför dessa Notes betyder så mycket i programmeringshistorien. De läser som tidigt beräkningsorienterat tänkande: att dela ett mål i precisa steg, välja representationer och förutse hur en mekanism kommer att följa dem.
Lovelace’s Notes förklarar vad vi idag skulle kalla programdesign. Hon beskriver Engine:ns delar (som ett minneslager och en processande “mill”) i termer av hur operationer kan sekvenseras och kontrolleras. Den centrala idén är enkel men djup: om Analytical Engine kan utföra operationer i en definierad ordning på definierade symboler, måste “hur” skrivas ner i en form maskinen kan exekvera.
Här börjar hennes arbete likna modern programmering. Det är inte bara teori; det är metod.
Viktigast är att Notes innehåller ett genomarbetat exempel presenterat som en tabell av steg. Den lägger upp, rad för rad, vad maskinen ska göra—vilka värden som finns i vilka platser, vilken operation som sker härnäst och var resultat lagras.
Den tabellformatet är en föregångare till dagens pseudokod, flödesscheman och instruktionstabeller: en tydlig, kontrollerbar plan du kan följa utan att gissa. Oavsett om du bygger en Analytical Engine eller inte, lär dig vanan den lär ut—att omvandla en idé till en exekverbar sekvens—är fortfarande kärnan i att skriva mjukvara.
En algoritm, i vardagligt språk, är en upprepbar metod: en uppsättning tydliga steg som pålitligt tar dig från en startpunkt till ett svar. Det är som ett recept som inte förlitar sig på intuition—om du följer stegen bör du få samma resultat varje gång.
Ada Lovelaces berömda exempelalgoritm syftade till att beräkna Bernoulli-tal—en följd av värden som dyker upp i många områden av matematiken (till exempel formler för summor som 1 + 2 + … + n, och i delar av analys). Du behöver inte förstå teorin för att uppskatta varför de är ett bra "testfall" för en tidig beräkningsmaskin.
De är lagom utmanande:
Med andra ord är det tillräckligt komplext för att bevisa att maskinen kan följa en strukturerad metod, men ändå ordnat nog att skrivas ner som steg.
I grunden har algoritmen en bekant struktur vi fortfarande använder i program:
Sett så här pekade Lovelace inte bara på ett tal som beräknas—hon visade hur man organiserar en flerstegsberäkning så att en maskin kan exekvera den utan att gissa.
När folk pratar om Lovelaces Bernoulli-algoritm fokuserar de ofta på resultatet ("ett tidigt program") snarare än det designarbete som gör steg pålitliga. Den verkliga bedriften är inte bara att lista operationer—det är att forma dem så en maskin kan följa dem utan improvisation.
I stället för att behandla "beräkna Bernoulli-tal" som en enda uppgift, delar Notes upp den i mindre delar som kan upprepas och kontrolleras: beräkna mellanvärden, kombinera dem i en viss formel, registrera resultat och sedan gå vidare till nästa fall.
Denna nedbrytning är viktig eftersom varje deluppgift kan valideras isolerat. Om ett utdata ser fel ut behöver du inte debugga "hela algoritmen"; du undersöker en del.
En mekanisk dator “behåller” inte saker i huvudet. Varje värde som kommer behövas senare måste lagras någonstans, och Notes är noggranna med det. Vissa tal är temporära arbetsvärden; andra är slutgiltiga resultat som måste bestå för senare steg.
Detta är ett tidigt tänkande kring programtillstånd:
Ordningen för operationer är en säkerhetsfunktion. Vissa beräkningar måste ske före andra, inte av elegans, utan för att undvika att använda ett oförberett värde eller av misstag skriva över något som fortfarande behövs.
I moderna termer utformar Lovelace kontrollflöde så att programmet har en klar väg: gör A, sedan B, sedan C—eftersom att göra B först tyst kan ge fel svar.
En av de mest "moderna" idéerna i Lovelaces steg-tabell är upprepning: förmågan att göra samma uppsättning instruktioner om och om igen, inte för att du sitter fast, utan för att upprepning är det snabbaste sättet att ett resultat.
Upprepning i ett program betyder: följ ett litet recept av steg, kontrollera om du är klar, och om inte, kör samma recept igen. Nyckeln är att något förändras varje gång—ofta en räknare, en position i en tabell eller värdet du bygger upp—så att programmet rör sig mot mållinjen.
I Lovelaces notation kan du se detta som en strukturerad återgång till tidigare steg. I stället för att skriva om identiska instruktioner många gånger beskriver hon ett mönster och indikerar när man ska cykla tillbaka. Det är fröet till det vi nu kallar iteration.
Om du har skrivit kod känner du igen mönstret som en for-loop ("upprepa detta N gånger") eller en while-loop ("upprepa tills ett villkor är uppfyllt"). Hennes tabell antyder också vanliga loopingredienser:
Föreställ dig att du vill summera 1 till 5.
total = 0i = 1i till totali med 1i fortfarande är 5 eller mindre, upprepa lägg-till-och-öka-stegetDetta är iteration i enkla termer: en liten loop som uppdaterar en räknare och ackumulerar ett resultat. Lovelace bidrog inte bara med vad hon beräknade—hon visade att upprepningsstrukturen kan skrivas ner tydligt nog för en maskin (och framtida människor) att exekvera pålitligt.
En procedur kan vara helt logisk i ditt huvud men ändå omöjlig för en maskin—eller en annan person—att följa utan ett sätt att referera till föränderliga kvantiteter. Där kommer variabler och notation in.
Tänk på en variabel som en märkt låda på ett skrivbord. Etiketten är densamma, men innehållet kan ändras medan du arbetar.
Om du beräknar en följd kan du ha:
Utan dessa lådor tvingas du beskriva allt i långa meningar ("ta talet du just beräknade för två steg sedan..."), vilket snabbt blir en röra.
I Lovelaces Notes finns symboler och etiketter inte för att se formella ut—de finns för att göra processen exekverbar. Tydlig notation besvarar praktiska frågor:
När procedurer blir långa förhindrar dessa små förtydliganden det vanligaste felet: att blanda ihop liknande kvantiteter.
Bra variabelnamn är fortfarande ett av de billigaste sätten att minska buggar. Jämför x1, x2, x3 med current_sum, term_index och next_term: den andra uppsättningen säger vad lådorna är till för.
Typer lägger till ett annat säkerhetslager. Att bestämma om något är ett heltal, ett decimaltal, en lista eller ett objekt är som att välja rätt slags behållare—vissa misstag blir omöjliga eller åtminstone lättare att fånga tidigt.
Variabler och notation förvandlar “en smart idé” till steg som kan upprepas korrekt, av vem som helst (inklusive en maskin).
Abstraktion betyder att fokusera på vad som är viktigt och medvetet dölja detaljer som inte spelar roll. Det är skillnaden mellan att säga "sortera den här listan" och att beskriva varje byte och jämförelse för hand. Lovelace’s Notes visar denna instinkt tidigt: de vill kommunicera en metod tydligt utan att tvinga läsaren att fastna i maskinens mekaniska detaljer.
En slående egenskap i Notes är hur de håller kärn-idén oberoende av maskinens fysiska handlingar. Analytical Engine har sitt eget "hur" (kugghjul, store, mill), men Notes betonar "vad": sekvensen av operationer som behövs för att nå ett resultat.
Den separationen är fröet till vad vi idag kallar mjukvarudesign:
När du kan beskriva metoden utan att återigen förklara maskinen behandlar du redan beräkning som något portabelt—möjligt att implementera på annan hårdvara eller av andra personer.
Steg-för-steg-tabellerna i Notes påminner om tidiga “procedurer”: en definierad uppsättning steg som kan följas om och om igen. Modern kod formaliserar detta som funktioner, moduler och återanvändbara komponenter.
En bra funktion gör vad Lovelace presentation gör:
Detta är varför abstraktion inte handlar om att vara vag—det handlar om att vara användbar. Återanvändning följer naturligt: när en metod uttrycks rent kan du kalla den i nya sammanhang, kombinera den med andra metoder och bygga större system utan att drunkna i detaljer.
Ada Lovelace beskrev inte bara vad Analytical Engine kunde göra—hon visade hur man gör en procedur entydig för en annan person (eller maskin) att följa. Det är Notes tysta styrka: de behandlar förklaringen som en del av arbetet, inte dekoration.
En anledning till att hennes presentation känns modern är användningen av strukturerade steg-tabeller. En tabell tvingar fram beslut som vag prosa kan dölja:
Det minskar tvetydighet på samma sätt som pseudokod gör idag. Du kan läsa ett stycke och tro att du förstår—tills du försöker exekvera det. En stegtabell gör "exekveringsvägen" synlig, vilket är exakt vad bra programdokumentation eftersträvar.
Lovelace’s Notes blandar tre saker vi fortfarande försöker hålla ihop:
Vad programmet är till för (avsikt)
Hur det fungerar (proceduren)
Hur man tolkar notationen (gränssnitt—namn, symboler, antaganden)
Detta motsvarar modern kommentarspraxis, docstrings och README-filer. En README förklarar mål och kontext. Inline-kommentarer förtydligar knepiga steg. Docstrings definierar inputs/outputs och kantfall. När någon av dessa saknas tvingas användaren gissa—och gissning är där buggar föds.
När du dokumenterar en process (kod eller inte), skriv som om någon kommer reproducera den utan dig:
Det är inget extraarbete—det är hur en metod blir återanvändbar.
Ada Lovelace introduceras ofta med en fet etikett: "den första programmeraren." Det är en användbar förenkling, men den kan också utplåna en mer intressant sanning. Debatten handlar inte bara om vem som får äran—det handlar om vad vi menar med program, dator och upphov.
Om "programmerare" betyder någon som skrev instruktioner avsedda för en allmän maskin har Lovelace ett starkt anspråk. I hennes Notes om Analytical Engine beskrev hon en steg-för-steg-metod för att generera Bernoulli-tal—i praktiken en plan för hur Engine kunde utföra en icke-trivial beräkning.
Men historiker diskuterar etiketten eftersom:
Det är viktigt att skilja på att uppfinna en datoridé och att bygga en fungerande dator. Babbage bidrog mest med arkitektur: en föreslagen maskin med minne ("store"), en processor ("mill") och styrning via hålkort. Lovelace bidrog med tolkning och uttryck: hon klargjorde vad en sådan maskin kunde representera och hur en procedur kunde skrivas ner så maskinen kunde följa den.
Ett program slutar inte att vara ett program för att hårdvaran aldrig levererades. I moderna termer är det som att skriva programvara för en plattform som fortfarande är teoretisk—eller specificera en algoritm innan kretsen finns.
Ett respektfullt sätt att tala om denna era är att betrakta den som ett samarbete över roller:
Vad vi med säkerhet kan säga: Lovelace’s Notes hjälpte till att definiera vad programmering är—inte bara beräkning, utan den noggranna uttrycksförmågan av en process som en maskin kan genomföra.
Notes betyder något eftersom de visar hur du tänker när du omvandlar en idé till en maskin-exekverbar plan. Även om du aldrig rör hålkort eller mekaniska kugghjul, kartlägger kärnlektionerna sig tydligt till modern programdesign: ge arbetet en tydlig struktur, namnge saker noggrant, använd upprepning med avsikt och bygg återanvändbara delar.
Struktur slår skicklighet. Ett program är enklare att bygga och underhålla när det bryts ner i steg med klar funktion. Lovelace uppmuntrar dig att designa lösningens form innan du hänger upp dig på detaljer.
Tydlighet är en funktion. Hennes tabeller och förklaringar var inte dekoration—de var en del av programmet. När framtida-du (eller en kollega) snabbt kan följa logiken blir programmet mer pålitligt.
Iteration är ett verktyg, inte ett trick. Upprepning (loopar) är hur du skalar en metod. Nyckeln är att definiera vad som upprepas, vad som förändras varje gång och när det slutar.
Abstraktion möjliggör återanvändning. Om en sekvens av steg fungerar en gång bör du kunna återanvända den med andra inputs. Det är grodden till funktioner, moduler och bibliotek.
Om du någon gång använt ett "bygg genom att beskriva"-arbetsflöde—skrivit krav, itererat på en plan och sedan genererat fungerande mjukvara—har du redan förkroppsligat Andan i Lovelace’s Notes: gör proceduren explicit, håll tillstånd tydligt och dokumentera antaganden så exekvering blir upprepbar.
Det är en anledning till att vibe-coding-plattformar som Koder.ai passar naturligt in i den här historien. Koder.ai låter dig skapa webb-, backend- och mobilapplikationer via ett chattgränssnitt, men samma grundprinciper gäller: du får bättre resultat om du specificerar inputs/outputs, namnger saker konsekvent och ber om steg-för-steg-struktur (planning mode kan hjälpa dig låsa fast "Notes" innan du genererar eller ändrar kod). Verktygen är nya; disciplinen är inte.
Använd denna snabba genomgång före kodstart—eller när du debuggar något som känns stökigt:
Om du vill stärka den "notes-first"-stilen i programdesign är dessa till hjälp:
Tillsammans förvandlar dessa vanor programmering från "få det att fungera" till "gör det begripligt"—samma förskjutning som Lovelace’s Notes redan pekade mot.
Ada Lovelaces “första algoritm” är ett steg-för-steg-förfarande (presenterat i hennes Notes) som var avsett att köras av Charles Babbage’s Analytical Engine. Den är berömd eftersom den behandlar beräkning som en planerad följd av operationer på lagrade värden, vilket liknar modern programmering även om maskinen inte byggdes färdigt.
Inlägget fokuserar på programmeringsidéerna i Lovelaces arbete—hur man uttrycker en metod så att den är exekverbar, kontrollerbar och begriplig—hellre än att rekonstruera Engine:ns hårdvara eller avgöra varje historisk detalj.
Analytical Engine var en föreslagen allmän maskin som var avsedd att:
Denna arkitektur är viktig eftersom den separerar hårdvara som exekverar från program som specificerar steg—samma uppdelning som moderna datorer bygger på.
Bernoulli-tal är en följd som dyker upp i flera matematiska formler. De är ett bra exempel eftersom varje nytt tal beror på tidigare tal, vilket kräver flera operationer, mellanstegslagring och upprepbara steg—precis den slags strukturerade arbete man vill testa på en programmerbar maskin.
Ett stegtabell tvingar fram precision. Den får dig att specificera:
Det är därför tabellen liknar modern pseudokod och hjälper andra att "köra" proceduren utan att behöva gissa.
Upprepning är tidig iteration: definiera en liten uppsättning steg, förändra något vid varje genomgång (som en räknare eller ett delresultat), och sluta när ett villkor uppfylls. I modern kod motsvaras det av for/while-loopar med:
Eftersom en maskin inte kan förlita sig på kontext eller minne som människor gör, låter tydliga, variabel-liknande etiketter dig hålla reda på:
Det minskar risken att blanda ihop liknande kvantiteter i långa procedurer.
Abstraktion separerar metoden (algoritmen) från mekaniken (hur maskinen genomför den). Det är början till återanvändbara komponenter:
I modern kod är detta hur funktioner och moduler gör system skalbara.
Etiketten är omdiskuterad eftersom:
Ett säkert uttalande är att hennes Notes tydligt formulerade vad programmering är: att skriva en entydig procedur en maskin kan följa.
Använd den här snabba genomgången innan du börjar koda:
För relaterade guider, se /blog/how-to-write-better-requirements och /blog/pseudocode-examples.