Programmeertaal — wat is het? Definitie, voorbeelden & werking

Er zijn vele soorten programmeertalen. De meeste programmeertalen volgen niet alleen één type, dus het is moeilijk om voor elke taal een type toe te wijzen. De voorbeelden van elk type worden hieronder gegeven omdat het de bekendste voorbeelden van dat type zijn.

Hoog niveau vs. laag niveau

High-level programmeertalen vereisen minder kennis van de hardware dan low-level programmeertalen. Dat komt omdat programmeertalen op hoog niveau abstraheren van de hardware waarop het programma draait. Veel high-level talen vereisen een interpreter om de broncode in realtime op de hardware uit te voeren. Anderzijds converteren low-level talen gewoonlijk de hele broncode naar machinecode voordat ze worden uitgevoerd, omdat de broncode zo dicht bij de hardware staat dat dit gemakkelijk kan. Hoog niveau vereist een compiler, maar laag niveau niet.

Declaratief vs. imperatief programmeren

Declaratieve programmeertalen beschrijven een "probleem", maar zeggen meestal niet hoe het probleem moet worden opgelost. De probleembeschrijving maakt gebruik van logica, en het "oplossen" van het probleem ziet er vaak uit als het automatisch bewijzen van een systeem van logische axioma's. Voorbeelden van dergelijke programmeertalen zijn Prolog, XSLT, LISP en SQL.

Imperatieve programmeertalen beschrijven een systeem van toestandsveranderingen. Bij aanvang bevindt het programma zich in een bepaalde toestand, en de computer krijgt stappen die hij moet volgen om een actie uit te voeren. Het volgen van de stappen zorgt ervoor dat het programma "van toestand verandert".

In het algemeen zijn declaratieve programmeertalen veiliger en korter. Imperatieve programmeertalen komen vaker voor, omdat ze gemakkelijker te gebruiken zijn.

Functioneel vs. procedureel

Functionele programmering bekijkt programmeren als een functie in de wiskunde. Het programma ontvangt input, samen met wat informatie, en gebruikt deze informatie om output te creëren. Het heeft geen tussentijdse toestand, en verandert ook geen dingen die geen verband houden met de berekening.

Procedurele programma's specificeren of beschrijven reeksen stappen of toestandsveranderingen.

Stack-based

Stack-gebaseerde talen bekijken een deel van het geheugen van het programma als een stapel kaarten. Er zijn heel weinig dingen die met een stapel kunnen worden gedaan. Een gegevensitem kan bovenaan de stapel worden geplaatst. Deze bewerking wordt meestal "push" genoemd. Een gegevensitem kan worden verwijderd van de top van de stapel. Dit wordt "pop" genoemd. U kunt het item bovenaan de stapel bekijken zonder het te verwijderen. Dit wordt een "peek" genoemd.

Als een programma is geschreven als "push 5; push 3; add; pop;" dan zal het 5 boven op de stapel zetten, 3 boven op de 5 zetten, de bovenste twee waarden optellen (3 + 5 = 8), de 3 en 5 vervangen door de 8, en de bovenste (8) afdrukken. Voorbeelden van programmeertalen die op stack gebaseerd zijn, zijn de talen Postscript en Forth.

Objectgeoriënteerde

Objectgeoriënteerde programmeertalen plaatsen gegevens en functies die gegevens wijzigen in een enkele eenheid. Deze eenheid wordt een "object" genoemd. Objecten kunnen met elkaar interageren en de gegevens van een ander object wijzigen. Dit wordt gewoonlijk inkapseling of informatieverberging genoemd. De meeste moderne programmeertalen zijn objectgeoriënteerd, of staan in ieder geval deze stijl van programmeren toe. Voorbeelden hiervan zijn Java, Python, Ruby, C++, C# en andere C-talen.

Stromingsgericht

Flow-georiënteerd programmeren ziet programmeren als het verbinden van verschillende componenten. Deze componenten sturen berichten heen en weer. Een enkele component kan deel uitmaken van verschillende "programma's", zonder dat deze intern gewijzigd hoeft te worden.

Wetenschappelijk computergebruik

Sommige van de bovenstaande talen kunnen worden gebruikt voor wetenschappelijke berekeningen. Bijvoorbeeld C++ en Python worden ook op deze manier gebruikt. Aan de andere kant zijn er enkele talen die wetenschappelijk rekenen als hoofddoel hebben. Hieronder volgen enkele voorbeelden:

• MATLAB - gemaakt door MathWorks
• GNU Octave, Scilab - open source versies van MATLAB.
• R (programmeertaal) - veel gebruikt op het gebied van statistiek
• Wolfram Mathematica - gemaakt door Wolfram Research

Aanmaken van documenten

LaTeX en SATySFi zijn programmeertalen die helpen bij het maken van documenten.

Elke programmeertaal heeft regels over wat wel en niet kan. Deze omvatten:

• Juiste getallen (soorten getallen, en hoe groot of klein de getallen kunnen zijn)
• Woorden (gereserveerde woorden, hoofdlettergevoeligheid)
• Grenzen aan wat de programmeertaal kan doen

De meeste talen hebben officiële standaarden die de regels bepalen voor het schrijven van de broncode. Sommige programmeertalen hebben twee of meer standaarden. Dit kan gebeuren wanneer een nieuwe standaard een oude vervangt. Bijvoorbeeld, de Perl 5 standaard verving Perl 4 in 1993. Het kan gebeuren omdat twee mensen tegelijkertijd twee standaarden hebben gemaakt. Er zijn bijvoorbeeld verschillende standaarden voor APL.

Object-georiënteerd programmeren (soms afgekort tot OOP) is een vorm van programmeren waarbij alle onderdelen van het programma objecten zijn. Objecten zijn stukjes geheugen met dezelfde structuur die steeds opnieuw kunnen worden gebruikt. Een bankrekening, een bitmap of een held uit een videogame kunnen allemaal objecten zijn binnen een programma. Objecten zijn opgebouwd uit eigenschappen (stukjes informatie die het object opslaat) en methoden die dingen zijn die het object kan doen. Een Hond-object kan eigenschappen hebben als hoogte en haarkleur. Zijn methoden zijn bijvoorbeeld blaffen() en kwispelen().

Alle objecten worden gemaakt van sjablonen die klassen worden genoemd. U kunt een klasse beschouwen als een mal waaruit objecten worden gemaakt. De klasse definieert alle eigenschappen en methoden die zijn objecten zullen hebben. Objecten die uit een klasse worden gemaakt, worden instanties van de klasse genoemd. Een klasse kan een andere klasse uitbreiden, wat betekent dat hij alle eigenschappen en methoden van de klasse overneemt, maar zijn eigen eigenschappen en methoden kan toevoegen.

Hier is een voorbeeld van hoe een klasse eruit zou kunnen zien in een programmeertaal:

class Dog extends Mammal{ //Dit zijn eigenschappen: String ras = "Collie" String type = "Herding Dog" //Dit zijn methodes void wagTail(){ //Doe wat kwispelen } void bark(){ //Doe hier het blaffen } } }

Merk op dat de klasse Hond de klasse Zoogdier uitbreidt, zodat alle honden de eigenschappen van een zoogdier hebben, zoals haarlengte, en methoden, zoals eten() of slapen().

Objectgeoriënteerd programmeren wordt gebruikt in veel van de populairste programmeertalen van vandaag, zoals Java, C#, Objective-C, C++, Python, Ruby, Javascript en ActionScript.

Voorbeeld van Visual Basic

Hier is een eenvoudig programma geschreven in Visual Basic (een taal van Microsoft):

Dit programma vraagt de gebruiker naar zijn of haar leeftijd en antwoordt op basis van wat de gebruiker heeft ingetypt. Als de gebruiker iets heeft ingetypt dat geen getal is, zegt het programma dat. Als de gebruiker een getal onder nul heeft ingetypt, zegt het programma dat ook. Als de gebruiker zegt dat hij of zij ouder is dan 100 jaar, zegt het programma "Dat is oud!". Als de gebruiker een correcte leeftijd heeft ingetypt, zegt het programma terug hoe oud hij of zij is.

Voorbeeld van Python

Hier is een programma dat hetzelfde doet als het programma hierboven, maar dan in Python:

Voorbeeld van C#

Hetzelfde als het programma hierboven, maar dan in C#:

Voorbeeld van Haskell

Weer hetzelfde, maar dan in Haskell:

• Algoritme
• Lijst van programmeertalen
• Programmeur
• Compiler
• Computer programmering
• Programmeerparadigma
• Pseudocode