Programmeertalen en programmeerparadigma’s

Een regel zoals x = a + b beschrijft een berekening zonder een processorregister te noemen. Abstractie maakt dit mogelijk: een taal verbergt details van lagere niveaus, zodat een programmeur zich kan richten op het werk dat het programma moet doen.

Wat de processor uitvoert

Machinecode bestaat uit instructies die als binaire getallen zijn gecodeerd. De instructiesetarchitectuur (ISA) van een processor bepaalt de instructies en hun coderingen. x86-64 komt veel voor in pc’s en servers; ARM komt veel voor in telefoons, tablets en veel laptops. Code die voor één ISA is gebouwd, moet worden vertaald of geëmuleerd om op een andere te werken.

Met hexadecimale notatie kun je instructiebytes korter weergeven. Op x86-64 zet B8 01 00 00 00 de waarde 1 in register EAX. De bytes 01 D8 tellen de waarde in EBX op bij EAX. Registers zijn kleine opslaglocaties binnen de processor. Elke instructie voert een kleine handeling uit, zoals gegevens verplaatsen, optellen, vergelijken of springen. De instructiecyclus voert deze instructies uit.

Namen voor dezelfde kleine handelingen

Assembleertaal vervangt instructiebytes door leesbare namen, mnemonics genoemd. Je kunt die twee x86-64-instructies zo schrijven:

mov eax, 1
add eax, ebx

Een assembler zet assembleertaal om in machinecode. Een gewone instructieregel levert normaal gesproken één machine-instructie op. Registernamen en instructies horen nog steeds bij een bepaalde ISA, dus woorden gebruiken in plaats van bytes maakt assembleertaal niet overdraagbaar.

Beschrijf een probleem in minder regels

Een hogere programmeertaal biedt variabelen, expressies, voorwaarden, lussen en functies. Python, C, Java en JavaScript laten de programmeur bewerkingen beschrijven zonder registers te kiezen. Eén instructie vereist vaak meerdere machine-instructies. Een vereenvoudigde vertaling van x = a + b zou:

1. De waarde van a in een register laden.
2. De waarde van b in een ander register laden.
3. De registerwaarden optellen.
4. Het resultaat voor x opslaan.

Een echte compiler kan die stappen combineren of anders ordenen met behoud van het vereiste gedrag.

Broncode in een hogere programmeertaal is gemakkelijker te lezen, te veranderen en te controleren. Overdraagbare C-broncode kan eenmaal voor een x86-64-systeem en opnieuw voor een ARM-systeem worden gecompileerd. Elke build heeft nog steeds de juiste ondersteuning van het besturingssysteem en de juiste bibliotheken nodig. Overdraagbare broncode maakt een native uitvoerbaar bestand niet universeel.

Waarom de lagere niveaus nog steeds van belang zijn

Assembleertaal blijft nuttig in opstartcode, sommige routines van besturingssystemen en stuurprogramma’s, kleine ingebedde systemen en beveiligingsanalyse van programma’s zonder beschikbare broncode. Voor gewone toepassingscode produceren moderne compilers meestal machinecode met prestaties die vergelijkbaar zijn met die van met de hand geschreven assembleertaal.

De verschuiving naar hogere niveaus vond geleidelijk plaats. Assembleertaal verspreidde zich eind jaren 1940 en begin jaren 1950. Het A-0-systeem van Grace Hopper hielp in 1952 de automatische vertaling vooruit. IBM bracht FORTRAN uit in 1957; COBOL volgde in 1959 en Lisp ontstond rond 1958–1960. “Hoger” duidt de afstand tot de hardwaredetails aan, niet hoe moeilijk de taal te leren is.

Een compiler vertaalt broncode naar doelcode. De doelcode kan native machinecode zijn of een tussenvorm zoals bytecode. Compilatie vooraf (ahead-of-time compilation, AOT) vindt plaats voordat het programma draait; just-in-timecompilatie vindt plaats tijdens de uitvoering.

Van tekst naar instructies

Bij een build vooraf zetten verschillende fasen een bronbestand om in instructies:

1. Lexicale analyse splitst tekst op in tokens: betekenisvolle stukken zoals namen, operatoren en getallen.
2. Syntactische analyse controleert de grammatica en bouwt een structuur die laat zien hoe de stukken in elkaar passen.
3. Semantische analyse controleert betekenisregels, waaronder declaraties en toegestane combinaties van typen.
4. Optimalisatie zoekt een efficiëntere manier om het vereiste werk uit te voeren.
5. Codegeneratie produceert de doelinstructies.

Neem de C-instructie total = price * 3;. De zes tokens zijn total, =, price, *, 3 en ;. De namen zijn identifiers, 3 is een letterlijke waarde van een geheel getal en de puntkomma beëindigt de instructie. De syntactische analyse legt vast dat de vermenigvuldiging binnen de toekenning hoort: bereken price * 3 en sla de waarde daarna op in total.

Deze fasen hebben verschillende taken. Een correct gespelde reeks tokens kan nog steeds de grammatica schenden. Een grammaticaal correcte instructie kan nog steeds een type verkeerd gebruiken. Tokens vinden is niet genoeg om vast te stellen dat een programma geldig is.

Doe hetzelfde werk met minder middelen

Stel dat broncode seconds_per_day = 60 * 60 * 24 bevat. De factoren zijn constanten, dus de compiler kan tijdens de build 60 met 60 vermenigvuldigen om 3600 te krijgen en dat vervolgens met 24 vermenigvuldigen om 86400 te krijgen. Hij kan de eindwaarde in de uitvoer plaatsen in plaats van de vermenigvuldiging tijdens de uitvoering te herhalen. Dit is constantevaluatie tijdens compilatie.

Een optimalisatie moet het gedrag behouden dat de taal vereist. Ze mag een berekening niet vervangen door een snellere die andere vereiste resultaten geeft. Het doel is om werk, tijd of geheugen te besparen met behoud van de betekenis van het programma.

Voeg de onderdelen samen

Grote programma’s worden meestal uit veel bestanden opgebouwd. Een compiler kan voor elk bronbestand een objectbestand maken. Een objectbestand bevat vertaalde code die mogelijk nog verbindingen met andere code nodig heeft. Een linker voegt de onderdelen samen en lost aanroepen naar bibliotheekroutines op, zoals afdruk- of wiskundige functies.

Het resulterende uitvoerbare bestand is gebouwd voor een doelplatform, inclusief een ISA en conventies van het besturingssysteem. De gebruiker heeft de compiler voor compilatie vooraf niet nodig om het uit te voeren. Gedeelde bibliotheken of uitvoeringscomponenten kunnen nog wel nodig zijn.

Begrijp wat een geslaagde build bewijst

In Java doorstaat int count = "five"; vóór de uitvoering een typecontrole niet. Tekst kan die variabele voor gehele getallen niet initialiseren. Het programma moet de vereiste controles tijdens de compilatie doorstaan voordat een uitvoerbare build beschikbaar is.

Andere fouten overleven de compilatie. Een deling door een door de gebruiker ingevoerde nul hangt af van gegevens tijdens de uitvoering. Een programma dat moet aftrekken maar in plaats daarvan optelt, kan draaien en de verkeerde waarde teruggeven. Compilatie controleert taalregels; tests moeten ook controleren of het resultaat bij de bedoelde taak past.

Een programma hoeft geen native uitvoerbaar bestand te worden voordat een gebruiker het start. Een interpreter voert het programma uit via een ander draaiend programma. Veel implementaties combineren interpretatie met compilatie, dus de nuttige vraag is hoe dit specifieke systeem code uitvoert.

Uitvoeren met een interpreter

Een interpreter moet beschikbaar zijn telkens wanneer die het programma uitvoert. Een interactieve REPL herhaalt vier handelingen: invoer lezen, evalueren, een resultaat afdrukken en terugkeren voor de volgende invoer. Dit geeft snel feedback wanneer je kleine expressies uitprobeert.

Interpreteren betekent niet noodzakelijk dat de ruwe broncode regel voor regel wordt gelezen. CPython, de standaardimplementatie van Python, compileert een bestand eerst naar bytecode. Een virtuele machine in software voert vervolgens die interne instructies uit. Bytecode hoort bij die uitvoeringsomgeving; het is niet de native instructieset van de processor.

Waarom sommige fouten eerder verschijnen

Vergelijk twee Python-bestanden. Dit bestand heeft geldige syntaxis:

print("start")
x = 10
print(x + "5")

Het drukt “start” af, koppelt x aan 10 en veroorzaakt vervolgens een TypeError. Het optellen van dat gehele getal bij een tekenreeks mislukt pas wanneer de expressie wordt uitgevoerd. Een vergelijkbare bewerking in een tak die niet wordt bereikt, kan onopgemerkt blijven totdat die tak wordt uitgevoerd.

Verwijder nu het sluithaakje uit de laatste regel. CPython kan het bestand niet compileren omdat de syntaxis onvolledig is. Het meldt een syntaxisfout voordat een instructie in dat bestand wordt uitgevoerd, dus “start” wordt niet afgedrukt. De syntaxiscontrole van het hele bestand en de controle tijdens de uitvoering van een bewerking vinden op verschillende momenten plaats.

Deel bytecode en specialiseer tijdens de uitvoering

Java laat een veelgebruikte hybride route zien. javac Hello.java produceert Hello.class, dat bytecode bevat. java Hello start een compatibele Java Virtual Machine (JVM). Verschillende JVM-implementaties laten die bytecode op verschillende processorfamilies draaien. De bytecode is overdraagbaar tussen compatibele uitvoeringsomgevingen; elke uitvoeringsomgeving moet zelf op het betreffende platform werken. C# richt zich op vergelijkbare wijze op een tussentaal die door .NET wordt gebruikt.

Een just-in-timecompiler (JIT-compiler) genereert machinecode terwijl het programma draait. De HotSpot-uitvoeringsomgeving van Java begint gewoonlijk met interpretatie en compileert veelgebruikte methoden. JavaScript-engines in browsers combineren ook uitvoeringstechnieken, waaronder JIT-compilatie. Veelgebruikte delen compileren kan de snelheid bij langdurige uitvoering verbeteren, maar kost tijd en geheugen tijdens de uitvoering.

Een lus die één miljard waarden optelt, draait doorgaans veel sneller in gecompileerde C dan in CPython: CPython voert bij veel bewerkingen interpreterwerk en typecontroles uit. Voor een script dat 20 bestanden hernoemt, kan de ontwikkelinspanning veel belangrijker zijn dan dat verschil. Meet de werklast voordat je een taallabel als voorspelling van de snelheid gebruikt.

Gecompileerd en geïnterpreteerd beschrijven keuzes in de implementatie. CPython gebruikt bytecode-interpretatie; PyPy gebruikt JIT-technieken. Een taal kan meer dan één implementatie hebben en één implementatie kan verschillende uitvoeringsmethoden gebruiken.

Syntaxis stelt de regels voor geldige programmatekst vast. Semantiek geeft die tekst betekenis. Een programma kan elke grammaticaregel volgen en toch het verkeerde resultaat berekenen, dus het controleren van de vorm is slechts het eerste deel van het lezen.

Herken de onderdelen en de grammatica

Tokens zijn onder meer sleutelwoorden zoals if, identifiers zoals total, letterlijke waarden zoals 3 of "hello", operatoren zoals + en ==, en leestekens. Een grammatica beschrijft hoe deze onderdelen expressies en instructies kunnen vormen.

Python vereist een dubbele punt na if x > 3: en gebruikt inspringing om de instructies te markeren die bij die voorwaarde horen. C, Java en JavaScript gebruiken accolades voor blokken; C en Java vereisen ook puntkomma’s na veel instructies. In die talen helpt inspringing de menselijke lezer, maar bepaalt die niet tot welk blok code behoort.

Verschillende syntaxis kan een vergelijkbare handeling uitdrukken. Deze instructies drukken een begroeting af:

print("hello")

printf("hello\n");

System.out.println("hello");

De C-escape \n voegt een nieuwe regel toe. Als je het idee van afdrukken kent, helpt dat bij het leren van de manier waarop elke taal dat uitdrukt.

Dezelfde symbolen kunnen verschillende dingen betekenen

Dat een symbool er vertrouwd uitziet, bepaalt niet de betekenis ervan in verschillende talen.

Ook de evaluatievolgorde is van belang. Door de voorrang vinden vermenigvuldiging en deling vóór optelling plaats. Met a = 4 en b = 6 deelt average = a + b / 2 eerst 6 door 2 en telt daarna 4 op, wat 7,0 oplevert. De haakjes in average = (a + b) / 2 zorgen dat de optelling eerst gebeurt en geven 5,0.

Maak onderscheid tussen fouten

Een syntaxisfout schendt de grammatica, zoals een ontbrekende dubbele punt in Python. Een uitvoeringsfout ontstaat tijdens een uitgevoerde bewerking, zoals een deling door nul in Python. Een logische fout laat uitvoering toe maar geeft een onbedoeld antwoord, zoals bij het onjuiste gemiddelde.

Sommige geldige expressies slaan bewust een bewerking over. In Python gebruikt x != 0 and 10 / x > 2 kortsluitevaluatie. Wanneer x nul is, is de eerste voorwaarde onwaar, zodat de rechterkant niet wordt geëvalueerd en er geen deling plaatsvindt. Als je deze voorwaarden omdraait, valt die bescherming weg. Python schrijft and, or en not; C, Java en JavaScript gebruiken &&, || en !.

Toekenning en vergelijking vormen een ander belangrijk onderscheid. = slaat een waarde op; == test gelijkheid. C staat if (x = 5) toe: het kent 5 toe en beschouwt die waarde ongelijk aan nul als waar. Python wijst if x = 5: af als ongeldige syntaxis. Dezelfde fout kan daardoor in verschillende talen in een andere fase worden opgemerkt.

Een kort programma is gemakkelijker te begrijpen wanneer je telkens één uitgevoerde instructie volgt. Houd de huidige waarden zichtbaar in plaats van van de eerste regel naar een geschat resultaat te springen.

Expressies en toekenningen

Een expressie levert een waarde op: price * 3, x > 10 en len(name) zijn voorbeelden. Een instructie voert een handeling uit, zoals een waarde toekennen of een blok aansturen. In total = price * 3 wordt de expressie rechts geëvalueerd voordat het resultaat aan total wordt toegekend.

Een variabele is een naam die naar een waarde verwijst. Een toekenning geeft de naam zijn huidige waarde; het is geen wiskundige bewering dat beide kanten altijd gelijk zijn geweest. Als count de waarde 4 bevat, leest count = count + 1 eerst 4, telt er 1 bij op en koppelt count aan 5.

Volg de volgende instructie die wordt uitgevoerd

Drie structuren organiseren het besturingsverloop:

• Een sequentie voert instructies op volgorde uit.
• Selectie gebruikt een voorwaarde om een route te kiezen, zoals bij if en else.
• Iteratie herhaalt een blok met een for- of while-lus.

De stelling van het gestructureerde programma, verbonden aan Böhm en Jacopini in 1966, laat zien dat deze structuren elk algoritme kunnen uitdrukken. Een for-lus doorloopt gewoonlijk de elementen van een verzameling. Een while-lus herhaalt zolang de voorwaarde waar blijft.

Bekijk deze Python-lus:

total = 0
for n in [3, 8, 5]:
    total = total + n

De ingesprongen toekenning wordt eenmaal voor elk element uitgevoerd. Een tracetabel legt de toestand na elke bijwerking vast:

Elk nieuw totaal gebruikt het vorige. Als je total binnen de lus zou terugzetten, zou dat een andere berekening opleveren omdat eerdere optellingen verloren zouden gaan.

Ga een functie binnen en verlaat die

Een functie groepeert een taak onder een naam. Een parameter is een naam in de definitie; een argument is een waarde die een aanroep doorgeeft:

def area(width, height):
    return width * height

result = area(3, 4)

De aanroep koppelt width aan 3 en height aan 4. De vermenigvuldiging levert 12 op en return stuurt die waarde naar de aanroeper. De uitvoering gaat verder bij de toekenning, zodat result de waarde 12 krijgt. De namen beschrijven één taak die met andere argumenten kan worden hergebruikt.

Een naam heeft een bereik

Het bereik bepaalt waar een naam kan worden gebruikt. Namen die binnen een functie worden aangemaakt, zijn gewoonlijk lokaal voor die aanroep. Een naam op het hoogste niveau is globaal binnen de module. Afzonderlijke aanroepen hebben afzonderlijke lokale koppelingen, ook wanneer ze dezelfde namen gebruiken.

count = 7

def reset():
    count = 0

reset()
print(count)

Dit drukt 7 af. De toekenning binnen reset maakt een lokale count aan; die vervangt de globale koppeling niet. Een functie kan in plaats daarvan een resultaat teruggeven en de aanroeper dat resultaat laten toekennen.

Bereik en levensduur beantwoorden verschillende vragen. Een lokale naam is niet beschikbaar voor code daarbuiten alleen omdat het object waarnaar die verwees nog bestaat. Teruggegeven objecten kunnen blijven bestaan en een teruggegeven geneste functie kan toegang houden tot variabelen uit de omsluitende aanroep; die bewaarde omgeving maakt deel uit van een closure.

Een gegevenstype bepaalt mogelijke waarden en de bewerkingen die daarop worden ondersteund. Een geheel getal ondersteunt rekenen met gehele getallen; een booleaanse waarde stelt waar of onwaar voor. Tekenreeksen, lijsten, records en objecten combineren of ordenen andere waarden. Typen sturen ook hoe waarden in het geheugen worden weergegeven, hoewel de grootte van een waarde kan afhangen van de waarde en de implementatie.

Wanneer worden typen gecontroleerd?

In Python is count = 5 gevolgd door count = "five" geldig. De naam verwijst nu naar een tekenreeks. Het evalueren van count + 1 veroorzaakt dan een TypeError. Bij dynamische typering hebben waarden een bepaald type; typen verdwijnen niet.

Statische typering vereist niet dat bij elke variabele zichtbaar een type staat. Met type-inferentie kan een compiler een type afleiden uit de omringende code. Kotlin leidt voor val n = 5 een geheel getal af en Rust kan voor let n = 5; een geheel getal afleiden. De optionele typeaanduidingen van Python zijn anders: aparte hulpmiddelen zoals mypy kunnen ze controleren, maar de gewone uitvoering van Python dwingt ze niet af.

Wanneer worden waarden geconverteerd?

Het controlemoment en de striktheid van conversie zijn aparte vragen. Python wijst "3" + 4 af; expliciete conversie in int("3") + 4 geeft 7. JavaScript past voor verschillende operatoren verschillende regels voor automatische conversie toe:

• "3" + 4 geeft de tekenreeks "34".
• "3" * 4 geeft het getal 12.
• "3" - 4 geeft het getal -1.

Automatische conversie heet impliciete typeconversie. De aanduidingen “sterke” en “zwakke” typering zijn informele manieren om de striktheid van conversie te bespreken, geen andere naam voor statische en dynamische typering. Python is dynamisch en strikt bij de gemengde optelling hierboven; C is statisch en staat toch veel impliciete numerieke conversies toe.

De functie input() van Python geeft een tekenreeks terug. Als iemand “30” intypt, heeft het resultaat nog steeds het type str. age + 1 mislukt, terwijl int(age) + 1 de waarde 31 geeft wanneer age die tekst bevat. Wat op het scherm verschijnt, is niet genoeg om het type te bepalen.

Getallen hebben grenzen aan hun representatie

Een geheel getal met teken van 32 bits geeft waarden van −2.147.483.648 tot en met 2.147.483.647 weer. De int van Java springt van het maximum naar het minimum wanneer er 1 bij wordt opgeteld. Overloop van gehele getallen met teken in C is ongedefinieerd gedrag, dus je mag in C niet uitgaan van dezelfde cyclische overloop. Gehele getallen in Python groeien zolang het geheugen dat toelaat: 2 ** 100 is precies 1.267.650.600.228.229.401.496.703.205.376.

Drijvendekommagetallen geven de meeste decimale breuken bij benadering binair weer. In Python en JavaScript levert 0.1 + 0.2 de waarde 0.30000000000000004 op. Een rechtstreekse vergelijking van dat resultaat met 0.3 geeft onwaar.

Als een berekening een kleine fout toelaat, vergelijk je waarden met een tolerantie die voor de taak is gekozen, bijvoorbeeld abs(a - b) < 1e-9. Zo’n kleine absolute tolerantie past slechts bij sommige grootordes. Gebruik voor exact decimaal boekhouden gehele kleinste eenheden of een geschikt decimaal type. De vergelijking veranderen kan een benaderende representatie niet exact maken.

Het hoofdgeheugen slaat de gegevens op van een programma dat draait. Elke byte heeft een adres. Talen bieden namen zodat programmeurs met waarden kunnen werken zonder voor elke bewerking ruwe adressen te schrijven.

Aanroepen gebruiken frames; objecten hebben een levensduur

In C neemt een int gewoonlijk 4 bytes in en haalt &x het adres van x op. Hogere programmeertalen verbergen adressen vaak achter referenties. Het belangrijke onderscheid is dat tussen een koppeling die een object benoemt en het object zelf.

De aanroepstapel houdt actieve functieaanroepen bij. Elke aanroep heeft een stapelframe met informatie zoals parameters, lokale koppelingen en waar de uitvoering na terugkeer moet doorgaan. Als main de functie area(3, 4) aanroept, wordt een frame voor area boven het frame van de aanroeper toegevoegd. De functie berekent 12, keert terug en het frame wordt verwijderd. Bij gewone geneste aanroepen keert de nieuwste aanroep het eerst terug.

Recursie voegt een aanroep toe voor elk nog niet afgerond niveau. Als aanroepen zich blijven opstapelen, kan de beschikbare stapelruimte opraken. Python veroorzaakt normaal gesproken een RecursionError na ongeveer 1.000 geneste aanroepen, waarbij de grens afhangt van de instellingen. Een stopvoorwaarde moet worden bereikt om een eindige recursieve berekening te laten eindigen.

De heap bevat dynamisch toegewezen objecten, zoals een lijst die groeit of een object dat langer bestaat dan de functie die het heeft gemaakt. Geheugentoewijzing reserveert opslagruimte. Een teruggegeven lijst kan op de heap blijven staan nadat de aanroep die de lijst maakte, is geëindigd.

Een referentie kopiëren deelt een object

Een referentie identificeert een object. Een pointer in C of C++ stelt expliciet een adres voor dat wordt gebruikt om toegang te krijgen tot gegevens. Het kopiëren van een referentie kopieert de toegang tot het object, niet alle gegevens van het object.

a = [1, 2]
b = a
b.append(3)

Na de eerste regel is er één lijst. De tweede regel koppelt er een andere naam aan. De laatste regel verandert die lijst, zodat zowel a als b [1, 2, 3] laat zien. Dit delen heet aliasing. Met b = a.copy() zou een afzonderlijke buitenste lijst ontstaan; bij deze lijst met gehele getallen zou toevoegen aan de nieuwe lijst a onveranderd laten.

Vergelijk toekenning met mutatie:

x = 5
y = x
y = y + 1

Het gehele getal 5 is onveranderlijk. De optelling levert 6 op en alleen y wordt opnieuw gekoppeld. x verwijst nog steeds naar 5. Getallen, tekenreeksen en tuples in Python zijn onveranderlijk; lijsten en woordenboeken zijn veranderlijk. De vaste inhoud van een tuple kan een referentie naar een veranderlijke lijst bevatten, dus onveranderlijkheid van de buitenste container bevriest niet elk genest object.

Pas dezelfde regels toe op argumenten

Wanneer Python een lijst aan een functie doorgeeft, verwijst de parameter naar hetzelfde object. Als je binnen de functie items.append(4) aanroept, verandert die lijst. De toekenning items = [] koppelt alleen de lokale parameternaam aan een nieuwe lijst. De naam van de aanroeper blijft aan het oorspronkelijke object gekoppeld.

C geeft argumentwaarden op waarde door. Om een functie de variabele van een aanroeper via haar adres te laten bijwerken, geef je een pointer daarnaar door. Stel bij het doorlopen in elke taal twee aparte vragen: “Naar welk object verwijst deze naam?” en “Verandert deze bewerking dat object of koppelt ze een naam aan iets anders?”

Toegewezen geheugen moet uiteindelijk opnieuw kunnen worden gebruikt. De uitdaging is gegevens na het laatste gebruik vrij te geven en tegelijk elk object te behouden dat het programma nog nodig heeft. Talen leggen deze verantwoordelijkheid bij de programmeur, een uitvoeringssysteem of door de compiler gecontroleerde eigenaarschapsregels.

Handmatig beheer en wat daarbij misgaat

In C vraagt malloc(n) om n bytes en geeft bij succes een pointer naar het blok terug. free(p) geeft een blok vrij dat door geheugentoewijzing is verkregen. De programmeur moet dat op het juiste moment en precies eenmaal doen. C++ ondersteunt ook handmatig beheer, hoewel de standaardhulpmiddelen vrijgave via de levensduur van objecten kunnen automatiseren.

Verschillende fouten hebben verschillende oorzaken:

Een pointer die naar vrijgegeven opslag blijft verwijzen, is verweesd. De opslag kan voor iets anders worden hergebruikt, dus toegang ertoe kan gegevens beschadigen of het programma laten vastlopen.

Voor een C-array int scores[10] zijn de geldige posities 0 tot en met 9. Schrijven naar scores[10] gaat voorbij de array en C biedt geen automatische grenscontrole. Python veroorzaakt een IndexError wanneer index 10 op een lijst met tien elementen wordt gebruikt, waardoor die toegang geen aangrenzend geheugen kan overschrijven.

Volg bereikbaarheid of tel referenties

Een garbage collector die bereikbaarheid volgt begint bij actieve wortels, zoals actieve referenties, volgt verbindingen tussen objecten en kan onbereikbare objecten opruimen. Java, C#, Go en JavaScript gebruiken methoden die bereikbaarheid volgen. Opruimen kost tijdens de uitvoering werk en geheugen; afhankelijk van de garbage collector kan het pauzes veroorzaken.

Referentietelling houdt referenties naar een object bij. Voor een nieuwe Python-lijst is de vereenvoudigde reeks: a = [1, 2] levert één referentie; b = a levert een tweede; del a verwijdert er één; b = None verwijdert de andere. CPython ruimt deze gewone lijst normaal gesproken op wanneer het aantal nul bereikt.

Een groep objecten kan elkaars aantallen boven nul houden, ook wanneer geen actief deel van het programma de groep kan bereiken. Dit is een referentiecyclus. CPython vult referentietelling aan met het opruimen van cycli. Referentietelling en het volgen van bereikbaarheid zijn beide technieken voor automatisch geheugenbeheer.

Controleer eigenaarschap vóór de uitvoering

Rust geeft elke waarde een eigenaar en controleert regels voor het lenen van referenties. Wanneer het eigenaarschap eindigt, geeft gegenereerde opruimcode de waarde vrij. Veilige Rust wijst gebruik af van referenties die langer zouden kunnen bestaan dan het geldige doel, zonder een garbage collector nodig te hebben die bereikbaarheid volgt. Swift gebruikt automatische referentietelling die door de compiler wordt ingevoegd.

Geheugenveiligheid is belangrijk om meer redenen dan vastlopende programma’s. Microsoft meldde in 2019 dat ongeveer 70% van de kwetsbaarheden waaraan het bedrijf jaarlijks CVE’s toekende, met geheugenveiligheid te maken had; Chromium meldde in 2020 een vergelijkbaar aandeel ernstige fouten. In december 2023 drongen CISA, NSA, FBI en internationale partners er bij softwaremakers op aan de overstap naar geheugenveilige talen te plannen.

Automatisch opruimen behoudt nog steeds bereikbare objecten. Een steeds groeiende globale lijst kan elk oud record in leven houden, ook nadat de applicatie het niet meer gebruikt. Een garbage collector kan niet bepalen dat deze bereikbare records voor de taak overbodig zijn geworden; het programma moet stoppen ze vast te houden.

Een programmeerparadigma is een manier om code te organiseren en over berekeningen na te denken. Bij imperatief programmeren geeft een programma opdrachten die zijn toestand veranderen: de waarden die variabelen en objecten op dat moment bevatten.

Maak de toestandsveranderingen zichtbaar

Een lopend totaal is een eenvoudige imperatieve berekening:

total = 0
for n in [3, 8, 5]:
    total = total + n

De begintoestand is total = 0. Door 3 op te tellen verandert die in 3. Door 8 op te tellen verandert die in 11. Door 5 op te tellen verandert die in 16. Elke toekenning gebruikt de toestand die de vorige stap achterliet, dus de volgorde maakt deel uit van de methode.

Deze stijl sluit aan bij de stapsgewijze veranderingen die de processor in registers en geheugen aanbrengt. De stijl past ook bij algoritmen die bewust een verzameling ter plekke bijwerken, zoals een sorteerroutine die elementen verwisselt.

Geef taken namen

Procedureel programmeren organiseert imperatieve code in functies of procedures. Een rapportageprogramma kan read_scores(), average(scores) en print_report(avg) aanroepen. Dankzij de namen kan een lezer de taak als geheel zien zonder meteen elke interne regel te volgen. Elke procedure kan afzonderlijk worden begrepen en getest.

C, Pascal, Fortran en COBOL zijn klassieke procedurele talen. Python ondersteunt deze stijl ook: een script kan benoemde functies gebruiken zonder klassen te definiëren.

Gestructureerd programmeren organiseert het besturingsverloop met sequentie, selectie, lussen en procedureaanroepen. Het vermijdt willekeurige sprongen die moeilijk te voorspellen maken welke instructie daarna wordt uitgevoerd. De brief “Go To Statement Considered Harmful” uit 1968 van Edsger Dijkstra hielp deze aanpak populair te maken. Gecontroleerde uitwegen zoals break, continue en return blijven nuttig: ze verlaten een bepaalde lusiteratie, lus of functie.

Effecten kunnen verder gaan dan een retourwaarde

Een neveneffect verandert iets buiten het teruggegeven resultaat van een functie. Afdrukken, een bestand opslaan, een netwerkbericht versturen en gedeelde gegevens veranderen zijn neveneffecten. Programma’s hebben zulke handelingen nodig om met de wereld te communiceren.

Problemen ontstaan wanneer niet-verwante code ongemerkt dezelfde toestand verandert. Stel dat apply_discount() een globale price met 10% verlaagt en add_shipping() er 5 bij optelt. Als je begint met 100, geeft eerst de korting toepassen 90 en daarna verzending toevoegen 95. Eerst verzending toevoegen geeft 105 en daarna de korting toepassen geeft 94,5. Beide procedures voeren hun eigen stappen correct uit, maar het gecombineerde resultaat hangt af van hun volgorde.

Door waarden door te geven en nieuwe resultaten terug te geven, kun je die volgorde zichtbaar maken:

price = add_shipping(apply_discount(100))

De binnenste aanroep wordt eerst uitgevoerd: korting, daarna verzending. Een andere nesting drukt een andere regel uit. Een duidelijke gegevensstroom helpt te zien of ook op de verzending korting moet worden gegeven.

Imperatieve code komt nog steeds veel voor binnen moderne objectmethoden en gebeurtenisafhandelaars. Een breder objectgeoriënteerd of functioneel ontwerp kiezen, verhindert niet dat een klein onderdeel directe opdrachten gebruikt waar die stappen het algoritme duidelijk maken.

Objectgeoriënteerd programmeren (OOP) modelleert een programma als samenwerkende objecten. Elk object combineert gegevens met bewerkingen op die gegevens. Een rekening kan de eigenaar en het saldo bevatten en tegelijk bewerkingen voor storten en opnemen aanbieden.

Maak onderscheid tussen de blauwdruk en de instanties

Een klasse definieert de attributen en methoden die haar objecten bieden. Een object, of instantie, is één specifiek exemplaar van die klasse. BankAccount is de blauwdruk; de rekening van Ana met 150 en de rekening van Ben met 40 zijn afzonderlijke instanties. Hun saldi kunnen onafhankelijk van elkaar veranderen.

Een attribuut slaat gegevens op die bij een object horen. Een methode is een bewerking die via een object wordt aangeroepen, zoals acct.deposit(50). self in een Python-instantiemethode verwijst naar het object dat de aanroep ontvangt.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self._balance = self._balance + amount

De aanroep BankAccount("Ana", 100) construeert een nieuwe instantie. De methode __init__ initialiseert de gegevens van die instantie. Een constructor is het proces dat een nieuw object klaar voor gebruik maakt; Python scheidt het maken van deze initialisatiestap. De aanroep acct.deposit(50) op die rekening verandert het saldo van 100 naar 150.

Plaats de regel waar de bijwerking gebeurt

Inkapseling brengt gegevens en de bewerkingen die de regels ervoor bewaken samen. Stel dat een rekening nooit een negatief saldo mag hebben. De opnamemethode controleert de voorgestelde verandering voordat die wordt uitgevoerd:

def withdraw(self, amount):
    if amount <= 0:
        raise ValueError("amount must be positive")
    if amount > self._balance:
        raise ValueError("insufficient funds")
    self._balance = self._balance - amount

Deze methode hoort binnen BankAccount. Bij een saldo van 150 veroorzaakt withdraw(200) een fout en blijft 150 over. withdraw(30) slaagt en laat 120 over. De mislukte aanroep trekt niet eerst af om daarna het probleem te ontdekken; de controle vindt vóór de bijwerking plaats.

Andere code hoort die methoden te gebruiken in plaats van een ongecontroleerd saldo toe te kennen. Java en C# kunnen directe toegang beperken met private. De voorloopunderscore in _balance van Python geeft volgens afspraak een intern detail aan; die dwingt geen afscherming af.

Informatieverberging gaat verder: aanroepers zijn afhankelijk van de bewerkingen die een klasse aanbiedt zonder de interne representatie te hoeven kennen. Het saldo zou later anders kunnen worden opgeslagen terwijl de openbare stortings- en opnamebewerkingen hun betekenis behouden.

Laat het probleem verantwoordelijkheden suggereren

Een bibliotheeksysteem heeft boeken, leden en uitleningen. Die zelfstandige naamwoorden suggereren mogelijke klassen of attributen; handelingen zoals lenen en verlengen suggereren methoden. Kies voor elke klasse één duidelijke verantwoordelijkheid. Een rekeningklasse die ook elke e-mail verstuurt en elk rapport opmaakt, wordt moeilijker te veranderen omdat niet-verwante taken worden gemengd.

Klassen en objecten verschenen in Simula 67 in 1967; Smalltalk hielp de aanpak in de jaren 1970 te verspreiden. Java, C#, C++ en Python ondersteunen OOP, maar het gebruik van een van die talen dwingt niet elk programma in klassen. De nuttige ontwerpvraag is welke gegevens en regels bij elkaar horen.

Objecten moeten vaak bewerkingen delen terwijl ze in details verschillen. Overerving, polymorfisme en compositie lossen verschillende delen van dat ontwerpprobleem op.

Specialiseer een bestaande soort object

Overerving definieert een subklasse vanuit een superklasse. In Python geeft class SavingsAccount(BankAccount): de gespecialiseerde klasse toegang tot geërfd rekeninggedrag. Ze kan add_interest(rate) toevoegen: een saldo van 1000 wordt met 2% rente 1020.

De bedoelde relatie is is-een. Een spaarrekening is nog steeds een bankrekening en moet voldoen aan de regels die voor bankrekeningen worden verwacht. Een paar regels hergebruiken is niet genoeg reden om te stellen dat de ene soort object een andere is.

Een subklasse kan een methode overschrijven met een eigen implementatie. Stel dat een betaalrekening 1 aan kosten rekent voor elke geslaagde opname. Bij een saldo van 100 kost een opname van 30 dan 31 en blijft 69 over. Om de rekeningregel te behouden, moet de methode de opname plus de kosten controleren voordat het saldo verandert. Als die gecombineerde kosten hoger zijn dan het saldo, weigert de methode de hele bewerking.

Laat één aanroep met verschillende objecten werken

Polymorfisme laat dezelfde bewerking op verschillende objecttypen werken. Een cirkel en een rechthoek kunnen beide area() aanbieden:

for shape in shapes:
    print(shape.area())

De lus heeft geen if nodig voor elke vormklasse. Elk object levert zijn eigen implementatie. Het selecteren van die implementatie tijdens de uitvoering heet dynamische methodekeuze.

Voor Circle(2) is de oppervlakte ongeveer 12,57 vierkante eenheden. Voor Rectangle(3, 4) is die 12 vierkante eenheden. Hun gezamenlijke oppervlakte is ongeveer 24,57 vierkante eenheden. Een latere Triangle kan aan de verzameling worden toegevoegd door een compatibele bewerking area() aan te bieden; de lus zelf heeft geen extra tak nodig.

Een interface geeft aan welke bewerkingen een type moet aanbieden. De Java-interface interface Shape { double area(); } vereist dat implementerende klassen de oppervlaktemethode leveren. Een abstracte klasse kan een deel van de gedeelde implementatie bieden en andere methoden overlaten aan subklassen. Python gebruikt vaak ducktyping: een object kan in de lus werken als het de vereiste bewerking biedt, ook zonder een gedeelde superklasse.

Bevat een onderdeel in plaats van het te worden

Compositie slaat andere objecten op als onderdelen. Een auto heeft een motor en wielen. De auto kan de methode start() van de motor aanroepen zonder van Engine te erven.

Diepe overervingsketens kunnen de gevolgen van een verandering in een superklasse door veel klassen verspreiden. Een subklasse die geërfd gedrag moet uitschakelen, kan wijzen op een slechte is-eenrelatie. Compositie houdt zulke afhankelijkheden vaak kleiner en duidelijker.

De vier veelgenoemde pijlers van OOP passen hier samen: inkapseling beschermt gegevens via bewerkingen, abstractie verbergt implementatiedetails, overerving specialiseert een type en polymorfisme laat een aanroeper een gedeelde bewerking op verschillende implementaties gebruiken.

Functioneel programmeren bouwt resultaten op door functies te combineren. De centrale werkwijze is nieuwe waarden uit invoer produceren en tegelijk gedeelde mutatie beperken. Lisp introduceerde rond 1958 veelgebruikte functionele ideeën; Haskell, Erlang, Clojure, F# en OCaml ontwikkelen die ideeën op verschillende manieren verder.

Weet wat een functie zuiver maakt

Een zuivere functie geeft hetzelfde resultaat voor dezelfde argumenten en heeft geen neveneffecten. def with_tax(price): return price * 1.2 illustreert het idee: with_tax(50) geeft 60.0. Een functie die ook iets aan een globale lijst toevoegt of een bericht afdrukt, heeft een effect naast de teruggegeven waarde. Een resultaat dat afhangt van de huidige tijd hangt ook van meer af dan de argumenten.

Een zuivere aanroep kan worden vervangen door de teruggegeven waarde zonder het gedrag van het programma te veranderen. Deze eigenschap heet referentiële transparantie. Ze maakt afzonderlijke tests eenvoudig en laat onafhankelijke aanroepen parallel draaien zonder te concurreren om een gedeelde toestand bij te werken.

Onveranderlijkheid houdt een bestaande waarde ongewijzigd. [n + 1 for n in nums] maakt een nieuwe lijst en laat nums intact. Een programma kan veranderende informatie nog steeds weergeven door nieuwe versies te maken; het hoeft de oude versie niet te overschrijven.

Geef gedrag als gegevens door

Functies zijn eersteklasfuncties wanneer ze aan namen kunnen worden toegekend, als argument kunnen worden doorgegeven en als waarden kunnen worden teruggegeven. Een functie van hogere orde ontvangt een functie of geeft er een terug. Een lambda-expressie is een naamloze functie-expressie, zoals lambda n: n * n.

Drie veelvoorkomende bewerkingen van hogere orde vormen een verwerkingsketen:

• filter behoudt elementen die aan een test voldoen.
• map transformeert elk overgebleven element.
• reduce combineert elementen met een accumulator tot één resultaat.

Om de kwadraten van de even getallen van 1 tot en met 6 op te tellen, blijven na het filteren 2, 4 en 6 over; kwadrateren geeft 4, 16 en 36; optellen geeft 56.

sum(map(lambda n: n * n,
        filter(lambda n: n % 2 == 0, range(1, 7))))

Hier controleert % 2 == 0 of een getal even is en levert range(1, 7) 1 tot en met 6. Haskell drukt dezelfde berekening uit als sum (map (^2) (filter even [1..6])).

Met reduce, geïmporteerd uit functools van Python, combineert reduce(lambda acc, n: acc + n, [3, 8, 5], 0) eerst 0 met 3 tot 3, dan met 8 tot 11 en dan met 5 tot 16. De verwerkingsketen beschrijft transformaties zonder een omringende lus die een gedeeld totaal bijwerkt.

Bewaar een omgeving of roep een kleiner probleem aan

def multiplier(k): return lambda x: k * x geeft een functie terug die toegang tot k behoudt. Daardoor geeft multiplier(3)(10) de waarde 30 terug, ook nadat de buitenste aanroep is afgerond. De teruggegeven functie en de bewaarde omgeving vormen een closure.

Bij recursie roept een functie zichzelf aan op een kleiner probleem. De faculteitsfunctie geeft 1 terug bij n == 0; anders geeft ze n * factorial(n - 1) terug. Voor 5 geven de vermenigvuldigingen 120. Een eindige berekening heeft een bereikbaar basisgeval nodig. Niet-afgeronde geneste aanroepen in Python veroorzaken uiteindelijk een RecursionError; talen met volledige ondersteuning voor staartaanroepen kunnen stapelruimte hergebruiken voor aanroepen op de laatste positie.

Alleen functies gebruiken maakt code niet functioneel: procedurele functies kunnen de toestand veranderen. Echte functionele programma’s lezen nog steeds invoer en schrijven uitvoer, waarbij ze effecten gewoonlijk aan de randen van het programma houden en de centrale berekeningen zuiver.

Declaratief programmeren beschrijft het gewenste resultaat en laat de uitvoeringsstappen over aan een taalengine. Functionele code wordt gewoonlijk onder dit brede idee geschaard, naast querytalen en logisch programmeren.

Lees een query als een verzoek

Een relationele database slaat gegevens op in tabellen. Stel dat students de rijen met naam en cijfer Ana 92, Ben 75, Chen 80 en Dara 64 bevat:

SELECT name
FROM students
WHERE grade >= 80
ORDER BY name;

FROM noemt de tabel, WHERE geeft de voorwaarde, SELECT kiest het teruggegeven veld en ORDER BY vraagt om alfabetische volgorde. Ana en Chen voldoen aan de voorwaarde, ook met Chens cijfer van precies 80. Het resultaat bestaat uit hun namen in die volgorde.

Een imperatief programma zou een resultatenlijst maken, rijen doorlopen, elk cijfer testen, namen die voldoen toevoegen en de lijst sorteren. SQL geeft de database het vereiste resultaat zonder die lus uit te schrijven.

Een queryoptimizer kiest een uitvoeringsplan. Die kan de tabel doorlopen of een beschikbare index gebruiken, een opzoekstructuur die geschikte zoekopdrachten kan versnellen. Veel indexen gebruiken gesorteerde structuren; andere gebruiken een andere ordening. Een index toevoegen kan het plan veranderen zonder de query te veranderen. Meer gegevens betekenen nog steeds werk: het resultaat declareren garandeert niet dat elke query weinig werk kost.

Vraag wat uit feiten en regels volgt

Logisch programmeren beschrijft feiten en relaties en zoekt vervolgens naar waarden die aan een vraag voldoen. In Prolog:

parent(tom, bob).
parent(bob, ann).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

De regel betekent dat X een grootouder van Z is wanneer er een Y bestaat waarvoor beide ouderrelaties gelden. De query ?- grandparent(tom, Who). vindt Who = ann: Tom is een ouder van Bob en Bob is een ouder van Ann. Namen met een hoofdletter staan voor variabelen; de namen in kleine letters duiden specifieke personen aan.

Herken declaratieve hulpmiddelen om je heen

Een spreadsheetformule =SUM(B2:B5) beschrijft een afhankelijkheid. Het spreadsheetprogramma berekent die opnieuw wanneer relevante cellen veranderen. De reguliere expressie [0-9]{3}-[0-9]{4} beschrijft drie cijfers, een koppelteken en vier cijfers, zoals in “555-0199”. Een tekstzoekengine voert de zoekopdracht uit.

CSS beschrijft het uiterlijk met een regel zoals h1 { color: navy; }; HTML markeert de structuur van een pagina. Het zijn declaratieve notaties die gewoonlijk als stijl- en opmaaktalen worden ingedeeld. Hun rol verschilt van die van een taal voor algemene doeleinden die een breed scala aan berekeningen kan uitdrukken.

Declaratieve code kan dicht bij een probleemstelling blijven en een engine de methode laten verbeteren. Ze geeft de programmeur ook minder directe controle over afzonderlijke stappen, wat het moeilijker kan maken de oorzaak van een traag plan vast te stellen. Daaronder worden nog steeds concrete instructies uitgevoerd: declaratief beschrijft hoe de programmeur de taak uitdrukt, niet een processor die zonder stappen werkt.

Een paradigma verandert hoe een oplossing wordt uitgedrukt, niet welk numeriek antwoord een correcte oplossing moet opleveren. Neem bestellingen met bedragen [120, 45, 300, 80]: bepaal het totaal van de bedragen die strikt groter zijn dan 100.

Volg veranderingen in de toestand

De imperatieve versie toont de lus en accumulator:

total = 0
for amount in amounts:
    if amount > 100:
        total = total + amount

Het eerste bedrag verandert total in 120. Het tweede laat de waarde onveranderd. Het derde verandert de waarde in 420 en het vierde laat die daar staan. Het programma maakt de volgorde van de test en de bijwerking zichtbaar.

Transformeer een verzameling

Een compacte Python-expressie in functionele stijl is sum(a for a in amounts if a > 100). Die selecteert 120 en 300 en combineert ze tot 420. Een andere versie is sum(filter(lambda a: a > 100, amounts)). Hier beschrijft het predicaat welke waarden erbij horen en combineert sum de geselecteerde waarden.

Een generatorexpressie of filter-aanroep gebruikt de mogelijkheden van Python voor meerdere paradigma’s; de aanwezigheid ervan maakt niet elk omringend deel van de applicatie zuiver.

Plaats regels bij objecten

In een objectgeoriënteerd ontwerp slaat een Order een amount op en biedt die is_large() aan, dat self.amount > 100 teruggeeft. Een OrderBook bevat bestelobjecten en biedt large_total() aan. Die methode kan bestellingen doorlopen, bij elk object vragen of het voldoet en de bedragen die voldoen optellen.

Het totaal blijft 420. Het verschil zit in waar de verantwoordelijkheden liggen: de regel voor een grote bestelling hoort bij Order en het werk op verzamelingsniveau hoort bij OrderBook. Andere functionaliteiten kunnen de regel hergebruiken zonder de drempeltest te kopiëren.

Vraag het de database

Als de gegevens al in een relationele database staan, kan SQL het totaal opvragen:

SELECT SUM(amount)
FROM orders
WHERE amount > 100;

De database kiest het plan voor ophalen en aggregeren. De query geeft een aanroeper geen opdracht om elke rij te bezoeken of een lokale accumulator bij te houden.

Combineer stijlen waar ze helpen

Python ondersteunt procedurele, objectgeoriënteerde en functionele technieken. JavaScript biedt objecten, eersteklasfuncties en closures. C++, C#, Kotlin, Scala, Swift en Rust mengen ook stijlen. Java wordt sterk met OOP geassocieerd maar ondersteunt sinds Java 8 in 2014 lambda-expressies; Haskell is zuiver functioneel.

Een webapplicatie kan klassen voor gebruikers en bestellingen gebruiken, functionele transformaties voor rapportgegevens, imperatieve bijwerkingen binnen methoden en SQL voor databasequery’s. Deze keuzes werken op verschillende lagen.

Gebeurtenisgestuurd programmeren voegt een ander organisatieprincipe toe: registreer een afhandelaar die wordt uitgevoerd wanneer een gebeurtenis binnenkomt. In JavaScript geeft button.addEventListener("click", showMenu) de functie showMenu als waarde door. Een latere klik roept die aan. De afhandelaar kan zelf objecten, zuivere transformaties of imperatieve stappen gebruiken. De gebeurtenisgestuurde rol zegt wanneer de afhandelaar draait, niet dat de inhoud maar één stijl mag gebruiken.

Geen enkele programmeertaal past het best bij elk project. Talen voor algemene doeleinden zijn doorgaans turingvolledig: met onbeperkte tijd en geheugen kunnen ze dezelfde klasse berekeningen uitdrukken. Echte keuzes hangen af van de vraag of een oplossing past bij het daadwerkelijke platform, de middelen, de hulpmiddelen en de mensen.

Begin met wat moet werken

Het platform is vaak een harde randvoorwaarde. Browsers voeren JavaScript uit en kunnen gecompileerde modules via WebAssembly uitvoeren. TypeScript voegt statische controles toe en compileert naar JavaScript. Swift is een gebruikelijke keuze voor apps op Apple-platforms; Kotlin wordt aanbevolen voor Android. SQL is de gebruikelijke taal voor relationele query’s.

Kijk daarna naar het domein en het ecosysteem. Python heeft veelgebruikte bibliotheken voor gegevens en machinelearning, zoals NumPy en pandas. R richt zich op statistiek. C en C++ komen veel voor in besturingssystemen, game-engines en code voor ingebedde systemen. Java en C# komen veel voor in grote bedrijfssystemen; Bash is nuttig voor het automatiseren van taken van het besturingssysteem.

Dit zijn praktische verbanden, geen exclusieve toepassingsgebieden. Een geschikte bibliotheek kan veel meer ontwikkelwerk besparen dan een klein verschil in de syntaxis van talen.

Onderzoek de behoeften aan middelen en veiligheid

Een microcontroller met slechts enkele kilobytes RAM heeft mogelijk nauwkeurige controle over het geheugen en de overhead tijdens de uitvoering nodig. C, C++ of Rust kan geschikt zijn waar het doelplatform die talen ondersteunt. Ook voor veeleisende onderdelen van games of databases gaat de voorkeur vaak uit naar die talen, maar engines en beschikbare middelen verschillen: Unity gebruikt C# en sommige databases gebruiken Java of Go.

Zoek voordat je op snelheid kiest het knelpunt: het onderdeel dat de prestaties beperkt. Een programma dat vooral op een netwerkantwoord wacht, wordt niet veel sneller alleen omdat een kleine lokale lus efficiënter wordt gecompileerd. Meet representatief werk op het doelplatform.

Geheugenveiligheid vermindert fouten zoals ongeldige geheugentoegang. Veilige Rust controleert eigenaarschapsregels tijdens de compilatie; beheerde talen zoals Java, C#, Go en Python bieden geheugenbeheer tijdens de uitvoering. Statische typering vangt veel incompatibele bewerkingen vóór de uitvoering op, wat in een grote codebase kan helpen. Noch geheugenveiligheid noch statische typering bewijst dat de logica van het programma correct is.

Neem de kosten voor onderhoud van het resultaat mee

De kennis van het team, beschikbare ontwikkelaars, debuggers, testhulpmiddelen, bibliotheken, licenties en bestaande code beïnvloeden allemaal de beslissing. Een vertrouwde, ondersteunde taal kan de kosten voor oplevering en onderhoud verlagen. Een werkend systeem herschrijven brengt migratiewerk en risico’s mee, ook als de nieuwe taal aantrekkelijke eigenschappen heeft.

Voor een stedelijk weernetwerk hebben verschillende onderdelen verschillende behoeften:

Een nuttige onderbouwing verbindt elke keuze aan een vereiste: “Het team onderhoudt de Java-service al en de bibliotheken ondersteunen de nieuwe functionaliteit.” Een plaats op een populariteitsranglijst alleen kan die redenering niet leveren. Enquêtes kunnen wijzen op een grote gemeenschap of een ruime groep beschikbare ontwikkelaars; ze stellen niet vast wat de beste taal voor een bepaalde werklast is.