Programmeerparadigma

In imperatieve programma's geven programmeurs de computer een reeks geordende stappen die moeten worden uitgevoerd om iets te doen. Als iemand wil dat de computer een kattengezicht tekent, kan hij aanwijzingen geven als "Teken hier een cirkel, teken daar twee kleinere cirkels, teken er twee driehoeken bovenop", enzovoort. Imperatieve programma's hebben soms veel neveneffecten.

Er zijn twee grote imperatieve paradigma's, en vaak heeft een taal beide:

• Gestructureerd - De computer krijgt aanwijzingen die altijd in een bepaalde volgorde staan. Stappen als "ga terug naar stap 3" (bekend als goto statements) zijn niet toegestaan.
• Procedureel - Het programma laat de programmeur een naam geven aan een lijst van opdrachten, waardoor die opdrachten worden omgezet in een "procedure" die hij later kan gebruiken. De meeste gestructureerde talen zijn ook procedureel.
• Object-georiënteerd - Ideeën worden aan de computer uitgelegd met behulp van objecten, stukjes code die een reeks opdrachten hebben die ze kunnen krijgen en enige informatie daarover.

In declaratieve paradigma's vertelt de programmeur de computer wat hij moet doen in plaats van hoe hij het moet doen. Als hij wil dat de computer een kattengezicht tekent, kan hij aanwijzingen geven als "Teken een gezicht, teken twee ogen, twee oren en een mond".

De bekendste declaratieve paradigma's zijn:

• Functioneel - Het meeste werk wordt gedaan door functies zonder bijwerkingen.
• Logica - Een reeks feiten wordt vermeld, en vervolgens worden een of meer "vragen" gesteld.
• Event-driven - Stukken code worden ingesteld om te worden uitgevoerd wanneer bepaalde dingen gebeuren (zoals het aanzetten van de computer).

Sommige paradigma's komen voor in zowel imperatieve als declaratieve talen. Deze paradigma's worden meestal gevonden met een van de bovenstaande paradigma's in plaats van op zichzelf te staan.

• Parallel: Meer dan één stuk code wordt tegelijkertijd uitgevoerd.
• Meta: Speciale dingen in de taal laten de programmeur de manier veranderen waarop de taal zelf handelt.

Programmeertalen worden gegroepeerd volgens paradigma's, net zoals machines kunnen worden gegroepeerd volgens het doel waarvoor ze worden gebruikt.

Enkele talen passen in slechts één hoofdparadigma, zoals:

• Smalltalk (objectgeoriënteerd)
• Assemblage (imperatief, maar niet gestructureerd of objectgeoriënteerd)
• Haskell (functioneel)
• Prolog (logica)

De meeste talen hebben echter meer dan één paradigma. Enkele talen die eruit springen omdat ze meer dan één paradigma hebben, zijn:

• Scala (objectgeoriënteerd, functioneel, parallel)
• Visual Basic (gebeurtenisgestuurd, objectgeoriënteerd)
• Common Lisp (procedureel, functioneel, objectgeoriënteerd, meta)
• Schema (functioneel, procedureel, meta)
• Perl (functioneel, procedureel, meta, objectgeoriënteerd, event-driven)
• Python (functioneel, objectgeoriënteerd, procedureel)
• Ruby (functioneel, objectgeoriënteerd, procedureel)
• Wolfram Language (functioneel, procedureel, over het algemeen declaratief)
• Oz (logisch, functioneel, imperatief, objectgeoriënteerd)
• F# (functioneel, imperatief, objectgeoriënteerd, meta)

Het hebben van meer paradigma's is niet altijd goed. Eén keer dat minder paradigma's een goede zaak kan zijn, is wanneer er een taal is die alleen functioneel is. Een functie in zo'n taal doet soms minder werk (zoals alleen de delen van een groep dingen overlopen die echt nodig zijn) dan wanneer de taal ook procedureel was.

Veel programmeerparadigma's zijn even bekend om de dingen die ze mensen niet laten doen als om de dingen die ze mensen wel laten doen. Dit geldt onder meer voor functionele talen. Als een functionele taal alleen of hoofdzakelijk functioneel is, laat deze meestal geen neveneffecten toe. Een ander voorbeeld hiervan is gestructureerd programmeren: dit verschilt van normale imperatieve talen omdat programmeurs geen "goto statements" mogen gebruiken (statements die het programma vertellen naar een eerdere stap te gaan). Om deze en andere redenen vinden mensen soms dat nieuwe paradigma's te weinig toestaan. Soms is het echter goed dat de computer mensen dingen niet laat doen: het kan mensen helpen om problemen met hun code te vermijden, en de computer gissingen laten maken zodat hij code sneller kan uitvoeren, of zelfs code controleren op problemen voordat de code wordt uitgevoerd!

Sommige mensen die programmeertalen bestuderen houden er niet van dat paradigma's worden gebruikt om programmeertalen te groeperen, zoals Harper en Krishnamurthi. Die mensen zeggen dat veel programmeertalen niet zomaar in paradigma's kunnen worden ingedeeld, omdat talen dingen en ideeën lenen van veel paradigma's.

In de loop der tijd zijn er nieuwe paradigma's ontstaan, en mensen hebben die destijds, of achteraf, aangewezen. Een van de eerste paradigma's die werd erkend als een nieuwe manier van programmeren was gestructureerd programmeren uit de jaren 1960. Het idee van een "programmeerparadigma" stamt uit 1978, zo niet eerder, toen Robert W. Floyd het gebruikte tijdens het lesgeven. Het woord "paradigma" zoals Robert het bedoelde, werd voor het eerst gebruikt door Thomas Kuhn in zijn boek The Structure of Scientific Revolutions (1962).

Machinecode

Het laagste niveau (het dichtst bij hoe de computer dingen wil begrijpen) en oudste programmeerparadigma is machinecode, een imperatief paradigma. De aanwijzingen in machinecode zijn gewoon een reeks getallen in een bepaalde volgorde. Assembleertaal is iets minder low-level (en iets minder oud). In assemblagetaal krijgen de aanwijzingen voor de computer mnemonics (gemakkelijker te onthouden namen), en kunnen geheugenadressen (aanwijzingen om een stukje informatie in de computer te vinden) namen krijgen. Deze talen worden soms eerste- en tweede-generatietalen genoemd.

In de jaren 1960 werden assemblagetalen beter gemaakt door nieuwe dingen toe te voegen zoals bibliotheek COPY, macro's (stukjes "speciale" code die werden omgezet in normale code voordat het programma begon te draaien), lopende procedures (reeksen aanwijzingen die een naam kregen en voor later werden opgeslagen), en variabelen (items die een naam kregen en voor later werden opgeslagen) van buiten het programma. Hierdoor konden mensen sommige code in meer dan één project gebruiken, en hoefden zij zich geen zorgen te maken over hardwarespecifieke problemen (problemen die zich slechts op één soort computer voordoen) dankzij commando's (namen voor aanwijzingen) als READ/WRITE/GET/PUT.

Assembly werd, en wordt soms nog steeds, gebruikt in systemen waar het belangrijk is dat de code snel is, en het wordt ook veel gebruikt in embedded systemen omdat het de gebruiker exacte controle geeft over wat de machine doet.

Procedurele talen

Aan het eind van de jaren zestig begonnen mensen procedurele talen uit te vinden. Deze talen van de derde generatie (de eerste paar van wat we nu high-level talen noemen) hadden woorden die verband hielden met wat ze probeerden op te lossen. Bijvoorbeeld,

• COmmon Business Oriented Language (COBOL) - gebruikt woorden als file, move en copy.
• FORmula TRANslation (FORTRAN) - gebruikt wiskundige woorden en symbolen (vormen gebruikt bij het schrijven en typen). Het werd vooral ontwikkeld voor wetenschap en techniek.
• ALGOrithmic Language (ALGOL) - gemaakt voor het schrijven van algoritmen (reeksen stappen die de computer vertellen wat hij moet doen). Het gebruikt wiskundige woorden en symbolen, net als FORTRAN.
• Programming Language One (PL/I) - moest nuttig zijn voor iedereen.
• Beginners All Purpose Symbolic Instruction Code (BASIC) - gemaakt om beginners te helpen programmeren.
• C - een programmeertaal die voor veel dingen bedoeld is. Dennis Ritchie werkte eraan van 1969 tot 1973 bij AT&T Bell Labs.

Objectgeoriënteerd programmeren

Nadat velen procedurele talen waren gaan gebruiken, werden objectgeoriënteerde programmeertalen uitgevonden. In deze talen worden gegevens en hun "methoden" (manieren om de gegevens te manipuleren) in één "object" gestopt. Sommige programmeurs, zoals Richard Stallman, zijn het er niet mee eens dat objectgeoriënteerde talen beter zijn om ideeën aan een computer uit te leggen dan procedurele talen.

Omdat objectgeoriënteerd programmeren een paradigma is en geen taal, heeft men objectgeoriënteerde assemblagetalen gemaakt zoals HLA (High Level Assembly).

Declaratieve paradigma's

Tegelijkertijd maakten sommige mensen declaratieve programmeertalen. Een taal die bekend staat als declaratief is SQL (een taal voor het toevoegen en verwijderen van dingen uit tabellen).