De ene taal is de andere niet, maar waarin verschillen ze nu precies?

In onze Python trainingen (Basis en Leren Programmeren) leren we onze cursisten de verschillende programmeerstijlen die deze taal ondersteunt: Procedureel en Object-Oriented programmeren. Daarnaast blijken er diverse taalconstructies in Python te zitten die Functioneel programmeren mogelijk maken. Maar wat betekenen deze termen nu eigenlijk?

We hebben ze voor je op een rijtje gezet.
Eerst wat definities (met dank aan Wikipedia):
Procedureel programmeren (PP) is een programmeerparadigma, afgeleid van gestructureerd programmeren, gebaseerd op het concept van de procedure-aanroep. Procedures, ook wel routines, subroutines of functies genoemd, bevatten eenvoudigweg een reeks uit te voeren computationele stappen. Elke gegeven procedure kan op elk moment tijdens de uitvoering van een programma worden aangeroepen, inclusief door andere procedures of zichzelf.” – Wikipedia

Object-Oriented programming (OOP) is een programmeerparadigma gebaseerd op het concept “objecten”, dat gegevens kan bevatten in de vorm van velden (vaak bekend als attributen) en code, in de vorm van procedures (vaak bekend als methoden). Een kenmerk van objecten is de procedure van een object die toegang heeft tot de datavelden van het object waaraan ze zijn gekoppeld en die ze vaak wijzigen” – Wikipedia

Functioneel programmeren (FP) is een programmeerstijl en een programmeerparadigma. Hierbij wordt de informatieverwerking in de vorm van functies uitgedrukt, vergelijkbaar met wiskundige functies. Bij deze stijl dienen (liefst alle) wijzigingen van variabelen buiten de functie (de zogenaamde “neveneffecten”) en het opslaan van programmatoestand en wijzigbare variabelen vermeden te worden.” – Wikipedia

Wat wordt er eigenlijk bedoeld met programmeerparadigma?
Je zou het kunnen zien als stijl van programmeren, een manier van denken over het bouwen van software. Het verwijst niet zozeer naar een specifieke taal, maar eerder naar een manier om te programmeren. Niet alle talen zijn geschikt om bepaalde paradigma’s toe te passen.

De meest grove indeling van programmeerparadigma’s is:

  • Imperatief – maakt gebruik van statements die de status van een programma wijzigen (vergelijk de gebiedende wijs in natuurlijke talen).
    Een imperatief programma bestaat uit opdrachten die de computer moet uitvoeren.
  • Declaratief – een niet-gebiedende programmeerstijl waarin programma’s de gewenste resultaten beschrijven zonder expliciet opdrachten of stappen op te geven die moeten worden uitgevoerd.
    Tot de declaratieve talen behoren de database query-talen (bijv. SQL, XQuery), reguliere expressies, functioneel programmeren, HTML en CSS.

We zoomen verder in op de drie paradigma’s
Kenmerkend voor Procedureel Programmeren (PP) is de top-down benadering. Procedurele programmeertalen zijn ook Imperatieve talen, vanwege de expliciete verwijzingen naar de toestand van de uitvoeringsomgeving. Denk hierbij aan variabelen.
De termen “procedureel” en “imperatief” worden vaak door elkaar gebruikt. Het programmeren van procedures is echter sterk afhankelijk van blokken en scope, terwijl imperatief programmeren in zijn algemeenheid niet over deze functies hoeft te beschikken. In procedurele talen komen we constructies tegen die in blokken werken, zoals if, while en for, om flow-of-control te implementeren. Niet-gestructureerde imperatieve talen gebruiken daarvoor goto-statements en branch-tabellen.

In Object-Oriented programming (OOP) worden gegevens en gedrag bij elkaar gebracht in objecten. Een OOP-applicatie gebruikt een verzameling objecten die weet hoe bepaalde acties uit te voeren en hoe de interactie met andere elementen van de toepassing geschiedt. Een object kan bijvoorbeeld een auto zijn. Zo’n auto heeft een merk- en een modelnaam (eigenschappen of attributen van het object), en zou weten hoe te rijden en te remmen (methoden van het object). Een methode in OOP is het equivalent van een procedure in PP, echter gekoppeld aan een specifiek object. Klassen vormen een belangrijk OOP-concept. Je kunt ze zien als een blauwdruk voor een object, ook wel instantie genoemd.

Functioneel programmeren (FP) gaat over het doorgeven van gegevens van functie naar functie naar functie om een resultaat te krijgen. In FP worden functies als gegevens behandeld, wat betekent dat je ze zelf ook als parameters kunt meegeven en ze kunt retourneren. Daarmee kun je functies uit andere functies opbouwen. Functies in FP moeten pure functies zijn; ze moeten gedeelde status en bijwerkingen vermijden en gegevens moeten onveranderlijk zijn. Een pure functie is idempotent: dezelfde invoer moet altijd dezelfde output opleveren, onafhankelijk van een lokale of globale toestand.
Door neveneffecten te elimineren is het gedrag van een programma veel gemakkelijker te begrijpen en voorspellen, wat een van de belangrijkste motivaties is voor het ontwikkelen in een functionele programmeerstijl.

Tot slot nog een overzichtje een aantal programmeertalen:

Onderwerpen
Actieve filters: Wis alle filters
Loading...