You are on page 1of 67

1

VOORWOORD
In onze bacheloropleiding elektronica-ICT ontdekten we dat er veel verschillende
programmeertalen worden gegeven in diverse hogescholen en universiteiten. Daarom
vonden we het zeer boeiend een onderzoek te starten waarbij de eigenschappen van een
programmeertaal worden bekeken en geanalyseerd. Dit onderwerp is interessant omdat we
zo zelf een beter beeld kunnen vormen van de verschillende kenmerken van de
programmeertalen. Dit zal ons helpen in onze carrière bij de beslissing welke
programmeertaal het meest passend is bij een project. Hierdoor zullen we een beter inzicht
krijgen in de vele programmeertalen die er zijn.
2

SYNTHESE
Aangezien er veel discussie bestaat rond welke objectgeoriënteerde programmeertaal
precies de beste is om aan te leren aan beginnende programmeurs (Mikoluk, 2013), vormt
dit een geschikt onderwerp voor een onderzoek. In deze studie beperken we ons tot
objectgeorienteerde programmeertalen en worden deze met elkaar vergeleken zodat
gekeken kan worden welke van deze talen precies het beste is om inzicht te verwerven in
het objectgeoriënteerd programmeren.
Er wordt gestart met een literatuurstudie rond de geschiedenis van de programmeertalen.
Ook de programmaparadigma’s en de conceptualisering rond programmeren worden
toegelicht om huidig onderzoek te kaderen en de nodige achtergrond weer te geven.
Een eerste stap in huidig onderzoek is het bepalen van de meest populaire talen. Hiervoor
wordt gebruik gemaakt van verschillende indicatoren, namelijk welke programmeertalen het
meest naar boven komen in jobadvertenties, boeken, websites, tutorials en zoekmachines
op het internet. Gezien de verschillende programmeertalen die bekomen werden op basis
van de indicatoren, werd ervoor gekozen meer duidelijkheid te scheppen aan de hand van
een enquête. Voor deze enquête werd gebruik gemaakt van een zelfselecterende steekproef
waarbij potentiële deelnemers zelf kunnen kiezen of zij al dan niet deelnemen. Zowel uit de
enquête, als uit de indicatoren blijkt dat Java een populaire programmeertaal is. Deze taal
blijkt eveneens de taal te zijn die de meerderheid van de respondenten kregen aangeleerd
tijdens hun opleiding en waar ze ook het meest ervaring mee hebben.
Op basis van de indicatoren en de enquête, werd gekozen voor vier programmeertalen,
namelijk Java, JavaScript, PHP en C#. Deze programmeertalen worden kort toegelicht. Er
wordt per programmeertaal aangehaald hoe deze ontstaan is, hoe deze wordt uitgevoerd en
hoe de toekomst van deze taal er uitziet.
Vervolgens wordt gekeken naar de fundamentele concepten van objectgeoriënteerd
programmeren. Uit een korte literatuurstudie blijkt dat er acht concepten van fundamenteel
belang zijn, namelijk inheritance, object, class, encapsulation, method, message passing,
polymorphism en abstraction. De gekozen programmeertalen worden vergeleken op basis
van deze fundamentele concepten.
3

INHOUD
Voorwoord ................................................................................................................................. 1
Synthese ..................................................................................................................................... 2
1 Literatuurstudie .................................................................................................................. 7
1.1 Geschiedenis van programmeertalen ......................................................................... 7
1.1.1 Wat is een programmeertaal? ............................................................................. 7
1.1.2 Ontstaan programmeertalen ............................................................................... 7
1.1.3 Inleiding van programmeertalen.......................................................................... 8
1.1.3.1 Machinetaal .................................................................................................. 8
1.1.3.2 Assembly ....................................................................................................... 9
1.1.3.3 3GL - Derde generatie programmeertalen ................................................... 9
1.1.3.4 4GL - Vierde generatie programmeertalen................................................... 9
1.2 Programmeerparadigma’s ......................................................................................... 10
1.2.1 Imperatief programmeren ................................................................................. 10
1.2.2 Objectgeoriënteerd programmeren .................................................................. 10
1.2.3 Reflectief programmeren ................................................................................... 10
1.2.4 Functioneel programmeren ............................................................................... 11
1.2.5 Generiek programmeren .................................................................................... 11
1.2.6 Event-driven programmeren .............................................................................. 11
1.2.7 Prototype-gebaseerd programmeren ................................................................ 11
1.3 Conceptualisering ...................................................................................................... 12
1.3.1 Compiler ............................................................................................................. 12
1.3.2 Interpreter .......................................................................................................... 12
1.3.3 JIT compiler ........................................................................................................ 12
2 Methode ........................................................................................................................... 13
4

2.1 Onderzoeksdoel ......................................................................................................... 13
2.2 Onderzoeksvragen en –doelstellingen ...................................................................... 13
2.3 Gegevensverzameling ................................................................................................ 14
2.3.1 Populariteitsgrafieken ........................................................................................ 15
2.3.2 Enquête .............................................................................................................. 15
3 Populariteit programmeertalen ....................................................................................... 18
3.1 Jobadvertenties ......................................................................................................... 18
3.1.1 JobsTractor ......................................................................................................... 18
3.1.2 Trendy Skills ........................................................................................................ 19
3.2 GitHub & Stack Overflow ........................................................................................... 20
3.3 Boeken ....................................................................................................................... 21
3.4 PYPL index .................................................................................................................. 22
3.5 TIOBE.......................................................................................................................... 23
3.6 Conclusie populariteitsgrafieken ............................................................................... 25
4 Onderzoek enquête .......................................................................................................... 26
4.1 Resultaten en analyseren gegevens .......................................................................... 26
4.2 Vergelijking resultaten enquête met populariteitsgrafieken .................................... 38
5 Overzicht van de gekozen programmeertalen ................................................................. 40
5.1 Java ............................................................................................................................ 40
5.1.1 Geschiedenis ...................................................................................................... 40
5.1.2 Uitvoering ........................................................................................................... 41
5.1.3 Toekomst ............................................................................................................ 41
5.2 C# ............................................................................................................................... 42
5.2.1 Geschiedenis ...................................................................................................... 42
5.2.2 Uitvoering ........................................................................................................... 43
5.2.3 Toekomst ............................................................................................................ 44
5

5.3 JavaScript ................................................................................................................... 46
5.3.1 Geschiedenis ...................................................................................................... 46
5.3.2 Uitvoering ........................................................................................................... 46
5.3.3 Toekomst ............................................................................................................ 47
5.4 PHP ............................................................................................................................. 47
5.4.1 Geschiedenis ...................................................................................................... 47
5.4.2 Uitvoering ........................................................................................................... 48
5.4.3 Toekomst ............................................................................................................ 48
6 Algemene vergelijking ...................................................................................................... 49
7 Vergelijking van de theoretische aspecten van Java, C++, PHP en JavaScript ................. 51
7.1 Inleiding ..................................................................................................................... 51
7.2 Inheritance ................................................................................................................. 52
7.2.1 Algemeen............................................................................................................ 52
7.2.2 Vergelijken .......................................................................................................... 53
7.3 Object......................................................................................................................... 53
7.3.1 Algemeen............................................................................................................ 53
7.3.2 Vergelijken .......................................................................................................... 53
7.4 Class ........................................................................................................................... 54
7.4.1 Algemeen............................................................................................................ 54
7.4.2 Vergelijken .......................................................................................................... 54
7.5 Encapsulation............................................................................................................. 55
7.5.1 Algemeen............................................................................................................ 55
7.5.2 Vergelijken .......................................................................................................... 55
7.6 Method ...................................................................................................................... 56
7.6.1 Algemeen............................................................................................................ 56
7.6.2 Vergelijken .......................................................................................................... 56
6

7.7 Message passing ........................................................................................................ 56
7.7.1 Algemeen............................................................................................................ 56
7.7.2 Vergelijken .......................................................................................................... 57
7.8 Polymorphism ............................................................................................................ 57
7.8.1 Algemeen............................................................................................................ 57
7.8.2 Vergelijken .......................................................................................................... 58
7.9 Abstraction ................................................................................................................ 58
7.9.1 Algemeen............................................................................................................ 58
7.9.2 Vergelijken .......................................................................................................... 58
8 Besluit ............................................................................................................................... 59
9 Bibliografie ....................................................................................................................... 60
10 Lijst van illustraties ........................................................................................................... 66
10.1 Lijst van tabellen .................................................................................................... 66
10.2 Lijst van figuren ...................................................................................................... 66

7

1 LITERATUURSTUDIE
1.1 GESCHIEDENIS VAN PROGRAMMEERTALEN
1.1.1 Wat is een programmeertaal?
De eerste programma's werden geschreven in zogenaamde machinetaal (hoofdstuk 1.1.3.1),
de taal waarin instructies geschreven zijn die de processor van een computer meteen kan
uitvoeren. Het is voor programmeurs echter zeer moeilijk om in machinetaal een
programma te schrijven omdat de instructies van een processor beperkt zijn. De instructies
omvatten namelijk vooral het manipuleren van bits in de processor. Abstractere begrippen
zoals getallen, tekst, complexe datastructuren, procedures,... bestaan niet op dit niveau.
Daarom werden in de loop van de jaren programmeertalen ontwikkeld die beter begrepen
kunnen worden door de mens. Elke instructie van een programmeertaal moet echter nog
steeds worden omgevormd naar machinetaal door middel van een compiler (hoofdstuk
1.3.1) en interpreter (hoofdstuk 1.3.2) (Smits, 2000).
1.1.2 Ontstaan programmeertalen
In 1957 ontstond één van de oudste hogere programmeertalen, FORTRAN
(FORmulaTRANslation), dewelke nog steeds gebruikt wordt in de ruimtevaart,
automobielindustrie, overheid en onderzoeksinstellingen. Deze taal werd ontwikkeld door
een IBM-teamleider genaamd John W. Backus voor high-level wetenschappelijke,
mathematische en statistische berekeningen (Nebel, 1998).
Twee jaar later, in 1959, ontstond COBOL (COmmon Business Oriented Language) voor
transactiesystemen zoals kredietkaartverwerking, geldautomaten, ziekenhuissystemen,
automobielindustrie, … Het COBOL-ontwikkelingsteam werd geleid door Dr. Grace Murray
Hopper (Bemer, n.d.).
In 1967 ontstond de eerste objectgeoriënteerde programmeertaal, Simula 67, ontwikkeld
door Ole-Johan Dahl en Kristen Nygaard van het Norwegian Computing Center in Oslo. De
taal werd beïnvloed door SIMSCRIPT en C.A.R. Tony Hoare's voorgestelde ‘record classes’
(Nygaard, 1978). De ideeën van Simula 67 beïnvloedden verschillende andere talen zoals
Smalltalk, Object Pascal en C++.
8

Smalltalk, ontwikkeld bij Xerox Parc door o.a. Alan Kay, introduceerde de term
objectgeoriënteerd programmeren om het alomtegenwoordige gebruik van objecten en
berichten als basis voor de berekening te vertegenwoordigen. Smalltalk-ontwikkelaars
werden beïnvloed door de ideeën van Simula 67. Smalltalk werd echter ontwikkeld als een
volledig dynamisch systeem waarin klassen kunnen worden gemaakt en dynamisch
aangepast. Bij Simula 67 was dit echter niet het geval daar het om een statisch systeem gaat
(Capretz, 2003).
In 1969 ontstond de programmeertaal C, ontwikkeld tussen 1969 en 1973 door Dennis
Ritchie, voor gebruik op Unix-systemen. De taal was zo succesvol dat 90% van de Unix-
besturingssystemen geschreven waren in C. De taal werd snel populair, ook in universiteiten
door de beschikbaarheid van goedkope compilers en het succes van Unix (Arora & Bansal,
2005).
In 1979 begon Bjarne Stroustrup van AT&T's Computing Science Research Centre van Bell
Laboratories een taal te ontwerpen, ‘C with Classes’. Deze werd alleen gebruikt door
werknemers van AT&T. In 1982 werd de taal herontworpen in een nieuwe taal die C++ werd
genoemd. De naam werd uitgevonden door Rick Mascitti (Seed, 2001).
Python ontstond in 1991 door Guido Van Rossum. De taal kan op verschillende
besturingssystemen worden uitgevoerd. Twee jaar later ontstond Ruby in 1993 dewelke
geschreven is in C. Het werd ontwikkeld door de kenmerken van vier andere
programmeertalen te combineren: Smalltalk, Eiffel, Lisp en Perl (Martijn Verkuil, 2011).
In de jaren '90 ontstonden Java (hoofdstuk 5.1.1), JavaScript (hoofdstuk 5.3.1) en PHP
(hoofdstuk 5.4.1). In het jaar 2000 ontstond C# (hoofdstuk 5.2.1). Deze programmeertalen
worden later in het onderzoek nog uitgebreid toegelicht.
1.1.3 Inleiding van programmeertalen
1.1.3.1 Machinetaal
Machinetaal is een taal met numerieke codes die een computer rechtstreeks kan uitvoeren.
De codes zijn een reeks van nullen en eenen (binaire cijfers of bits). Vaak worden ze voor de
leesbaarheid omgezet naar hexadecimale getallen. Elke binaire code staat voor een
specifieke actie die de processor kan uitvoeren. Wanneer er in het programma bijvoorbeeld
9

"00101100" staat, kan dit betekenen dat de inhoud van register 1 opgeteld moet worden bij
register 0. Machinetaal is moeilijk om te schrijven en lezen, omdat het niet op menselijke
taal lijkt. Daarnaast variëren de codes van computer tot computer (Hemmendinger, 2008).
1.1.3.2 Assembly
Voor programmeurs is het zeer tijdrovend om software in machinetaal te schrijven. Om deze
reden werd een taal ontwikkeld die voor mensen makkelijker te begrijpen is, namelijk
Assembly. Het maakt gebruik van korte ezelsbruggetjes om instructies uit te voeren.
Hierdoor kan de programmeur namen gebruiken om bewerkingen uit te voeren op
geheugenblokken. Een voorbeeld hiervan is "MOV X,Y" in de x86 assembleertaal. Het
kopieert de data van het ene register naar het andere. De assembleertaal is zo ontworpen
dat het gemakkelijk omgezet kan worden naar machinetaal. Net als bij machinetaal moet je
een goede kennis hebben van de processor waarvoor je schrijft.
1.1.3.3 3GL - Derde generatie programmeertalen
De derde generatie programmeertalen is een groep van programmeertalen die belangrijke
verbeteringen heeft ten opzichte van Assembly. Deze generatie is vooral bedoeld om de
programmeertaal gebruikersvriendelijker te maken, waardoor het de commando’s van
Assembly niet gebruikt. Engelse woorden worden gebruikt om allerlei elementen
(variabelen, structuren) aan te duiden. Deze generatie behoort tot de groep high-level
programmeertalen. De meeste programmeertalen die vandaag worden gebruikt behoren tot
deze groep (C, C++, Java, enz.) (Techopedia, 2014b).
1.1.3.4 4GL - Vierde generatie programmeertalen
De vierde generatie programmeertalen is een groepering van programmeertalen die nog
dichter bij de menselijke taal aansluiten. 4GL’s zijn ontworpen om de totale tijd, inspanning
en kosten voor softwareontwikkeling te verminderen. De belangrijkste eigenschappen zijn:
database query’s, automatisch rapporten aanmaken, data manipulatie, analyse,… Het
gebruikt woorden en zinnen die afgeleid zijn uit het Engels. Soms worden ook iconen,
grafische interfaces en symbolische representaties gebruikt. Vele 4GL worden geassocieerd
met databases en verwerking van gegevens. Vele van deze datageoriënteerde talen baseren
zich op SQL (Structured Query Language). Enkele voorbeelden zijn Ruby, LabVIEW, Python en
SQL (Techopedia, 2014a).
10

1.2 PROGRAMMEERPARADIGMA’S
Een programmeerparadigma is een stijl van computerprogrammeren, een manier voor het
bouwen van structuur en elementen. Een verschil tussen verschillende paradigma’s is
voornamelijk de wijze van aanpak om het gewenste resultaat te kunnen behalen. Sommige
programmeertalen zijn ontworpen om slechts één paradigma te ondersteunen, andere
kunnen meerdere ondersteunen. C# is er één van (imperatief, objectgeoriënteerd, event-
driven, functioneel,...), ook wel multi-paradigmaprogrammeertalen genoemd.
1.2.1 Imperatief programmeren
Imperatief programmeren is een programmeerconcept waarin stapsgewijs in code wordt
omschreven wat een programma moet doen. Het is nog steeds het meest toegepaste
paradigma. Imperatief programmeren wordt soms ook wel procedureel programmeren
genoemd.
1.2.2 Objectgeoriënteerd programmeren
Objectgeoriënteerd programmeren is een programmeerparadigma waarbij logische objecten
worden gemaakt, dewelke op elkaar inwerken. Deze objecten bevatten methodes, functies,
acties en eigenschappen (Kedar, 2007).
Om objectgeoriënteerd goed te begrijpen nemen we een ‘hand’ als voorbeeld. Een hand is
een klasse. Een lichaam heeft twee objecten van het type hand, namelijk een linkerhand en
een rechterhand. Het hand wordt opnieuw gebruikt voor het linker- en rechterhand. Er zijn
kleine wijzigen in de eigenschappen van elk hand (bijvoorbeeld de duim staat op een
verschillende plaats op beide handen).
Programmeertalen waarmee objectgeoriënteerd geprogrammeerd kan worden, zijn
bijvoorbeeld C++ en Java. De mogelijke bewerkingen die de programmeur kan uitvoeren
staan beschreven in de headers, bibliotheken (libraries) en API's (Application Programming
Interfaces),…
1.2.3 Reflectief programmeren
Bij reflectief programmeren kan het programma tijdens het uitvoeren zijn eigen structuur
bekijken en veranderen. Reflectie komt meestal voor in high-level programmeertalen, zoals
11

Smalltalk en scripttalen, maar ook in talen zoals Java, Haskell, C# en Scala. Met reflectie kan
je nieuwe instances aanmaken terwijl het programma draait.
Bij Java geeft reflectie je de mogelijkheid om de interne informatie van een klasse (die in de
Java Virtual Machine, JVM, geladen zijn) te bekijken. Je kan nieuwe code schrijven die werkt
op de klasse die wordt uitgevoerd (Sosnoski, 2003).
1.2.4 Functioneel programmeren
Talen die functioneel programmeren ondersteunen, maken gebruik van functiedefinities.
Om na te gaan of de functies gedefinieerd zijn, zal het programma tijdens het uitvoeren
geëvalueerd worden. Vervolgens zullen de functies worden uitgevoerd (Kedar, 2007).
1.2.5 Generiek programmeren
Bij generiek programmeren dient de code zo algemeen mogelijk te zijn. Niet de broncode die
wordt gecompileerd wordt geschreven, maar wel de templates van de broncode. Enkele
voorbeelden van generiek programmeren zijn arrays, lists en maps. Veelgebruikte functies
zullen zo worden geschreven dat ze gebruikt kunnen worden met verschillende parameters
of types. Dit voorkomt dat dezelfde code, die alleen verschilt in parameters of types,
meerdere keren wordt geschreven. Java, C# en C++ zijn enkele talen waar dit kan worden
toegepast (Dos Reis, 2005).
1.2.6 Event-driven programmeren
De flow van het programma wordt bepaald door events (gebeurtenissen) zoals
gebruikersacties (muisklik, knop induwen) of data van andere programma’s threads. Bij
sequentieel programmeren is de flow van het programma vooraf al vastgesteld, wat bij
event-driven niet het geval is. Nadat er een event plaatsvindt, worden de bijhorende
functies uitgevoerd (Ferg, 2006).
1.2.7 Prototype-gebaseerd programmeren
Class-gebaseerde objectgeoriënteerde talen zoals Java en C++, zijn gebaseerd op het
concept van twee verschillende entiteiten: klassen en instanties.
Een prototype-gebaseerde taal, bijvoorbeeld JavaScript, maakt dit onderscheid niet. Het
heeft enkel objecten. Een prototype-gebaseerde taal heeft een object dat wordt gebruikt als
een template. Hieruit kan men de eigenschappen halen voor een nieuw object. Elk object
12

kan verbonden worden als het prototype van een ander object, zodat het tweede object de
eigenschappen van het eerste object kan overnemen (Mozilla Developer Network, 2014a).
1.3 CONCEPTUALISERING
1.3.1 Compiler
Een compiler is een softwareprogramma dat de broncode van een specifieke taal zal
converteren naar een andere taal. In het algemeen wordt de compiler gebruikt om de
broncode van een high-level programmeertaal (C#, Java, etc.) om te vormen naar
machinetaal (hoofdstuk 1.1.3.1). Een compiler zal meestal eerst de broncode naar Assembly
omzetten en dan pas naar machinetaal. Ook zal hij extra voorbereidingstijd nodig hebben
om het volledige programma te vertalen, voordat het programma kan worden uitgevoerd.
Deze werking kan worden onthouden als ‘pile together’, het zal het volledige programma
samenvoegen en in één keer vertalen (Freedman, 2014a).
1.3.2 Interpreter
Een interpreter zal de broncode van een high-level programmeertaal op hetzelfde moment
omvormen en uitvoeren. De interpreter zal een programmastatement vertalen naar
machinetaal, uitvoeren en dan naar het volgende statement gaan. Deze methode is trager
dan een compiler, maar gemakkelijker om fouten op te zoeken aangezien je lijn per lijn kan
testen (Freedman, 2014b).
1.3.3 JIT compiler
Een JIT (Just-In-Time) compiler zal, nadat het programma gestart is, de broncode compileren
wanneer deze wordt gebruikt. Een JIT zal toegang krijgen tot runtime informatie waar een
standaard compiler geen toegang tot heeft. Zo kan de JIT optimalisaties uitvoeren, zoals
inlining toepassen op veelgebruikte functies. In plaats van het genereren van andere code
om de functie op te roepen, zal bij inline-functies de compiler de code van een veelgebruikte
functie invoegen op alle plaatsen waar deze wordt opgeroepen. Hierdoor zal de tijd
verkleinen die nodig is om de functie op te roepen. Dit in tegenstelling tot een traditionele
compiler, die alle code naar machinetaal zal omvormen voordat het programma wordt
uitgevoerd (Freedman, 2014c).
13

2 METHODE
2.1 ONDERZOEKSDOEL
Programmeertalen zijn gemaakt om applicaties te schrijven die uitgevoerd worden op de
computer. High-level programmeertalen hebben als belangrijkste vereiste dat ze (in
tegenstelling tot machinetaal en Assembly) leesbaar zijn voor mensen. Je kan kiezen tussen
verschillenden talen die elk hun voor- en nadelen hebben. In principe heeft elke
programmeertaal dezelfde (theoretische) mogelijkheden. Meer bepaald is (nagenoeg) elke
programmeertaal in staat een berekening uit te voeren die een andere programmeertaal
ook kan, ook wel Turing-compleet genoemd.
In deze studie zoeken we de meest gebruikte objectgeoriënteerde programmeertalen, die
vervolgens met elkaar worden vergeleken. Hieruit beogen we te concluderen welke taal men
best als eerste aanleert om inzicht te werven in het programmeren. Er zijn meer dan 100
verschillende objectgeoriënteerde programmeertalen. Sinds 2010 zijn er nog 8 nieuwe
objectgeoriënteerde programmeertalen bijgekomen waaronder Rust, Dart en Hack.
Om de populariteit van een taal te bepalen kan men zich baseren op verschillende
elementen zoals populaire zoekopdrachten, jobadvertenties en programmeertalen die in
onderwijsinstellingen gegeven worden.

2.2 ONDERZOEKSVRAGEN EN –DOELSTELLINGEN
Er bestaan veel discussies rond welke objectgeoriënteerde programmeertaal precies de
beste is en volgens Mikolu (2013) is één van de eerste vragen die nieuwe studenten
computerwetenschappen stellen: “Welke taal moet ik leren?”. Het antwoord op deze vraag
is complexer dan verondersteld wordt. Verschillende talen hebben verschillende
mogelijkheden en toepassingen. Sommige talen worden vaker gebruikt in enterprise-
instellingen zoals Java, terwijl anderen een hoofdbestanddeel zijn van web applicaties zoals
PHP.
14

Als student is het interessant om te onderzoeken welke programmeertalen het meest
toegankelijk zijn voor beginnende programmeurs. Het spreekt voor zich dat voor wie al een
taal kent, het eenvoudiger is om een nieuwe taal aan te leren. Daarnaast zijn sommige
programmeertalen toegankelijker dan andere.
Een veel gestelde vraag is welke programmeertaal het meest aanbevolen is om het
objectgeoriënteerd programmeren onder de knie te krijgen. Informaticastudenten hebben
doorgaans weinig keuze. De programmeertaal die zij als eerste aanleren is immers diegene
die de onderwijsinstelling aanbiedt.
Om zicht te krijgen op de programmeertalen die het meest populair zijn, wordt eerst een
enquête afgenomen. De onderzoeksvragen die beantwoord zullen worden met de enquête
zijn: ‘Welke programmeertaal is het populairste volgens de respondenten?’ en ’Welke
programmeertaal is het meest toegankelijk voor beginnende programmeurs?’. Door vragen
te stellen als welke taal ze het eenvoudigste vinden om het objectgeoriënteerde
programmeerparadigma te leren kennen, wat hun favoriete objectgeoriënteerde
programmeertaal is en of ze het gemakkelijk vinden om code te schrijven in die taal.
Vervolgens wordt op zoek gegaan naar de belangrijkste concepten van objectgeoriënteerd
programmeren. Dit omdat huidig onderzoek zich enkel richt op objectgeoriënteerde
programmeertalen. Na de bepaling van deze concepten, zullen ze worden vergeleken in 4
verschillende talen die verder in het onderzoek worden gekozen (hoofdstuk 7). De
onderzoeksvraag die met dit deel beantwoordt wordt is: ‘Welke taal is het eenvoudigste om
de essentiële elementen van objectgeoriënteerd programmeren aan te leren?’.
2.3 GEGEVENSVERZAMELING
Om de populariteit van de verschillende programmeertalen na te gaan, wordt in twee
stappen gewerkt. In een eerste stap zal op basis van verschillende populariteitsgrafieken
worden nagegaan welke programmeertalen het meest populair blijken. Vervolgens zal een
enquête opgesteld worden waaruit eveneens moet blijken welke talen volgens de
respondenten de meeste populariteit genieten. Ten slotte zullen de resultaten uit beide
gegevens vergeleken worden om tot een algemeen beeld te komen van de meest populaire
programmeertalen.
15

2.3.1 Populariteitsgrafieken
Een eerste stap in de dataverzameling is het verzamelen van gegevens rond de populariteit
op basis van verschillende indicatoren waarbij programmeertalen belangrijk zijn. Een eerste
aspect waar naar gekeken wordt zijn jobadvertenties. Er wordt gekeken naar de
programmeertalen die het meest worden aangegeven bij jobadvertenties voor software
ontwikkelaars. Om dit na te gaan wordt gebruik gemaakt van JobsTractor en Trendy Skills.
Een tweede aspect waarnaar wordt gekeken, zijn websites rond programmeren. Hierbij
wordt voor twee verschillende websites gekeken welke programmeertalen het meest naar
voor komen en het populairste zijn. De websites die worden gebruikt zijn GitHub en Stack
Overflow. Vervolgens wordt gekeken naar de boekenverkoop. De programmeertalen
waarvan het meeste boeken gekocht werden, worden gezien als de meeste populaire
programmeertalen. Hiervoor wordt gebruik gemaakt van data uit rapporten van BookScan.
Daarnaast wordt ook gekeken naar de hoeveelheid tutorials die worden opgezocht voor de
verschillende programmeertalen. Deze informatie komt voort uit PyPL index. Een laatste
indicator die wordt gebruikt, is hoe vaak de programmeertalen worden ingetypt in
zoekmachines op het internet. Hierbij wordt gebruik gemaakt van de informatie die
vrijgegeven wordt door TIOBE.
2.3.2 Enquête
Om de populariteit te bepalen, bezorgen we een vragenlijst aan studenten en ervaren
programmeurs in Vlaanderen. Zo kunnen we een beeld vormen over de programmeertalen
die de voorkeur krijgen bij studenten. Verschillende voor- en nadelen kunnen worden
bepaald via webpagina's, tijdschriftartikels en reeds gemaakte onderzoeken.
Er werd gekozen voor een enquête omdat deze het mogelijk maakt om op een zeer
economische wijze een grote hoeveelheid gegevens uit een omvangrijke populatie te
verzamelen. Deze gegevens zijn gestructureerd waardoor ze gemakkelijk te vergelijken zijn.
Met een enquête kunnen kwantitatieve gegevens worden verzameld, die vervolgens met
behulp van beschrijvende statistiek kunnen worden geanalyseerd. Daarnaast kunnen
bepaalde verbanden tussen variabelen duidelijk worden door gebruik te maken van een
enquête.
Vooraleer de gegevens van de enquête zullen worden geanalyseerd, worden de vragen
weergegeven die opgesteld werden voor de enquête. De onderzoeksvragen die hiermee
16

worden beantwoord zijn welke programmeertaal volgens de respondenten het populairste
en het meest toegankelijk zijn.
De eerste vragen betreffen de leeftijd en status (student, werknemer, werkzoekende) van de
respondent, alsook aan welke hogeschool ze gestudeerd hebben of nog studeren en welke
opleiding ze gevolgd hebben of nog volgen.
De vragen die de respondenten beantwoorden zijn ‘Welke objectgeoriënteerde
programmeertalen zag/ziet u op hogeschool of universiteit?’, ‘In welke objectgeoriënteerde
programmeertalen heb je ervaring?’, ‘Welke objectgeoriënteerde programmeertalen zou je
nog willen leren?’, ‘Wat is volgens jou de beste programmeertaal om het
objectgeoriënteerde programmeerparadigma te leren kennen?’, ‘Wat is de eerste
objectgeoriënteerde taal die je geleerd hebt?’ en ‘Wat is uw favoriete objectgeoriënteerde
programmeertaal?’. Ook hebben we gevraagd hoelang ze al programmeerervaring hebben,
iemand die al meer ervaring heeft zal andere antwoorden geven.
Daarnaast werd nagegaan welke van de objectgeoriënteerde programmeertalen volgens de
respondenten het populairste zijn. Dit wordt bij de analyse vergeleken met de
populariteitsgrafieken in hoofdstuk 3. Vervolgens gaan we dieper in op de taal die zij het
meest gebruiken. Hierbij wordt gevraagd hoe vaak ze in deze taal programmeren, hoe ze
hun kennis zouden omschrijven omtrent deze programmeertaal en of ze makkelijk
informatie vinden over deze taal en het makkelijk is om hiervoor code te schrijven.
Gegevens verzamelen over de gehele populatie van programmeurs zou voor de meest
representatieve resultaten zorgen, maar aangezien dit praktisch onhaalbaar is, moeten we
deze gegevens verzamelen aan de hand van een steekproef. Werken met steekproeven
bespaart ons tijd, waardoor we meer tijd hebben voor het onderzoeken van andere
elementen in dit onderzoeksrapport. Het gebruik van een steekproef is een goed alternatief
indien het onderzoeken van de populatie niet haalbaar is (Saunders et al., 2011). Er kan
meer gedetailleerde informatie verkregen worden dan bij een census (onderzoek over de
gehele populatie). De onderzoekspopulatie zijn programmeurs in Vlaanderen. Ideaal zouden
we de hele populatie onderzoeken, maar omdat dit niet haalbaar is, werd er een steekproef
in Vlaanderen genomen. Het gaat om een zelfselecterende (niet-stochastische) steekproef
waarbij de persoon zelf aangeeft te willen deelnemen aan het onderzoek. Of ze al dan niet
17

willen deelnemen wordt met andere woorden overgelaten aan (potentiële) respondenten.
Deze zelfselectie leidt er meestal toe dat de steekproef niet representatief is en zorgt er met
andere woorden voor dat de steekproef moeilijk te generaliseren valt.
De respons is het deel van de steekproef dat gereageerd heeft op de uitnodiging om deel te
nemen aan het onderzoek. Onze enquête werd naar verschillende universiteiten en
hogescholen verstuurd. We kregen veel respons van HoGent, Thomas More Geel,
Hogeschool West-Vlaanderen en Universiteit Gent.
De vragen uit de enquête werden opgemaakt met behulp van ‘Google Forms’. Respondenten
konden deze enquête online invullen. Door gebruik te maken van een online enquête wordt
de drempel hem in te vullen kleiner. Ook administratief zijn hier voordelen aan verbonden.
Zo worden gegevens overzichtelijk weergegeven en kunnen ze makkelijker worden
geanalyseerd.
De interpretatie van de enquête gebeurde door twee onderzoekers. Hierdoor wordt de
validiteit verhoogt. De uitgebreide rapportering over de doelgroep en de gebruikte methode
zorgt voor een hogere externe betrouwbaarheid.



18

3 POPULARITEIT PROGRAMMEERTALEN
Eerst zijn we op zoek gegaan naar de programmeertalen die we van naderbij zouden
bekijken in dit onderzoek. Zoals reeds gezegd in hoofdstuk 2 zijn er verschillende indicatoren
waarop men zich kan baseren om de populairste programmeertaal te vinden. Deze worden
hieronder weergegeven en besproken.
3.1 JOBADVERTENTIES
Er wordt gebruik gemaakt van twee verschillende websites om na te gaan welke
programmeertalen het meest populair zijn in jobadvertenties.
3.1.1 JobsTractor

Figuur 1 JobsTractor advertenties van januari 2014
19

Jobs Tractor baseert zich op jobadvertenties voor softwareontwikkelaars op Twitter (Figuur
1) (Warren, 2014). De vacatures die gebruikt worden zijn globaal, maar enkel tweets in het
Engels worden opgenomen in de grafiek. Aangezien het hier enkel gaat om Engelstalige
tweets, kunnen zich vragen worden gesteld rond de representativiteit van deze gegevens.
3.1.2 Trendy Skills

Figuur 2 Trendy Skills zoekopdrachten
Trendy Skills baseert zich op zoekopdrachten rond vaardigheden waar werkgevers naar
zoeken op populaire advertentiewebsites (Figuur 2). De data is afkomstig van landen zoals
Verenigde Staten, Griekenland, Verenigd Koninkrijk, Zweden, Spanje en Duitsland (Trendy
Skills, 2014).
De gegevens die voortkomen uit de verschillende websites rond jobadvertenties verschillen
sterk van elkaar. De populairste taal is voor beide website dezelfde, namelijk Java. De andere
programmeertalen komen vaak in beide advertenties aan bod, maar hebben een andere
populariteitsgraad. Dit is mogelijks te verklaren doordat bij JobsTractor enkel gebruik wordt
20

gemaakt van Engelse tweets, terwijl het bij Trendy Skills om allerlei websites gaat waar
werkgevers op zoek zijn naar specifieke vaardigheden. Bij Trendy Skills gaat het eveneens om
andere landen dan bij JobsTractor. Zo worden gegevens uit landen als Zweden, Griekenland,
Spanje en Duitsland gebruikt bij Trendy Skills, terwijl dit niet noodzakelijk het geval is bij
JobsTractor, daar het hier enkel om Engelse tweets gaat.
3.2 GITHUB & STACK OVERFLOW

Figuur 3 RedMonk Programming Languages Ranking
Deze grafiek (Figuur 3) toont zowel de gegevens van GitHub (een open source project
hosting website), als van Stack Overflow (Q&A website voor programmeren) (O’Grady,
2014). Op de verticale as wordt de populariteit van programmeertalen op Stack Overflow
weergegeven in ‘aantal voorkomende tags’. De horizontale as toont de populariteit op
GitHub in ‘aantal projecten’. De minst populaire programmeertalen staan links onderaan en
de populairste staan rechts bovenaan. De populairste objectgeoriënteerde
programmeertalen in deze grafiek bij zowel Stack Overflow als GitHub zijn Java, JavaScript en
PHP.
21

GitHub omvat zowel oude als nieuwe projecten. Als een taal twee jaar geleden populair was,
zal dit nog steeds zwaar doorwegen, zelf als de projecten niet langer actief zijn.
De gegevens van Stack Overflow geven een behoorlijke indicatie rond populariteit, maar niet
iedereen maakt gebruik van deze website, waardoor de gegevens niet eenduidig kunnen
worden gegeneraliseerd.
3.3 BOEKEN

Figuur 4 Top 20 programmeertalen gebaseerd op boeken in 2010 en 2011
Bovenstaande grafiek is gebaseerd op verkoop van boeken over een periode van een jaar
(Figuur 4). De cijfers komen uit rapporten van BookScan van de top 3000 titels die verkocht
werden van verschillende uitgevers. Het nadeel hier is dat niet elke programmeur boeken
koopt en niet iedereen die een boek koopt de taal gebruikt (Brockmeier, 2012).
22

3.4 PYPL INDEX

Figuur 5 PyPL Index
PyPL staat voor Popularity of Programming Language index en wordt gecreëerd door hoe
vaak tutorials worden opgezocht op Google (Carbonnelle, 2014). Hoe meer naar een
bepaalde tutorial van een taal wordt gezocht, hoe populairder de taal wordt geacht (Figuur
5). Ze maken gebruik van het sleutelwoord tutorial om verschillende redenen. Alleen de
naam van de taal zou tegenstrijdige resultaten opleveren. Python heeft bijvoorbeeld veel
verschillende betekenissen, het is zowel een slang als een programmeertaal. Het
sleutelwoord "programming" is ook geen oplossing omdat er meer op "C programming"
gezocht wordt dan "PHP programming". Het sleutelwoord tutorial is een woord dat vaak
wordt gebruikt door ontwikkelaars die een nieuwe taal willen leren. De ruwe data is
afkomstig van Google Trends.
Zowel Java als JavaScript blijven behoorlijk stabiel. Objective-C werd in het jaar 2009-2010
waarschijnlijk verward met C, dit zou de stijging kunnen verklaren. De groei van C# gaat ten
koste van C++ en Basic, de groei van Python ten koste van Perl (Carbonnelle, 2014).
23

3.5 TIOBE

Figuur 6 TIOBE Index
TIOBE Index is gebaseerd op onder andere zoekopdrachten van 25 verschillende
zoekmachines, het aantal geschoolde technici wereldwijd, cursussen en externe
leveranciers. De grafiek geeft data weer tot mei 2014. De TIOBE Index wordt elke maand
vernieuwd.
Android (hoofdzakelijk Java) en iOS (Objective-C) zijn de grootste mobiele platformen.
Windows Phone (hoofdzakelijk C#) is minder populair, zoals te zien is in figuur 7. De figuur
toont de smartphone verkoop wereldwijd. Android wordt het meest verkocht en in TIOBE is
Java het populairste. iOS wordt het op één na meest verkocht en in de TIOBE index staat
Objective-C na Java. We merken op dat de verkoop van Windows Phone vrij laag is en ook C#
is in de TIOBE index het laatste jaar gedaald.

24


Figuur 7 World-Wide Smartphone Sales (%) (Rivera & Van der Meulen, 2014)

Figuur 8 TIOBE Index lange termijn
In figuur 8 zien we de geschiedenis in populariteit op lange termijn. Het zijn gemiddelde
posities gedurende 12 maanden.
25

3.6 CONCLUSIE POPULARITEITSGRAFIEKEN
Na het bekijken van alle grafieken stellen we vast dat één objectgeoriënteerd taal in elke
grafiek als eerste staat, namelijk Java. Hieruit kan besloten worden dat Java een vrij
populaire taal is.
De rest van de talen verschillen van grafiek tot grafiek. Enkele talen die frequent bovenaan
staan zijn onder andere JavaScript, PHP, C# en C++. Javascript blijkt bovenaan te staan bij de
gegevens uit de websites rond programmeren, uit Trendy Skills bij de jobadvertenties en bij
de meest verkochte boeken. PHP blijkt een populaire programmeertaal te zijn volgens de
gegevens van JobsTractor en PyPL, maar bij de overige indicatoren neemt deze taal echter
een gematigde positief in. C# staat bij de websites programmeren redelijk hoog, bij de
andere indicatoren is er echter sprake van een gematigde positie. Ook C++ neemt bij de
verschillende posities hoge tot gematigde posities in.


26

4 ONDERZOEK ENQUÊTE
4.1 RESULTATEN EN ANALYSEREN GEGEVENS
Wat is uw leeftijd?


Figuur 9 Leeftijd Enquête
In totaal kregen we 195 reacties, waarvan 77% tussen de 19 en 25 jaar en 12% tussen 26 en
40 jaar oud.
Ik ben op dit moment


Figuur 10 Enquête: Student, werknemer of werkzoekende
Van onze respondenten zijn 150 student, 42 respondenten zijn werknemers en 2
werkzoekend.

27

Aan welke hogescho(o)l(en) of universiteit(en) heb je gestudeerd?


Figuur 11 Enquête: Hogeschool/Universiteit
Het gaat om drie hogescholen in de top drie van het hoogste responspercentage (Figuur 11).
De meeste respons kwam van Hogeschool Gent (39%), wat geen verrassing is aangezien dit
ook onze onderwijsinstelling is. Thomas More Geel is met 17% de school met het tweede
hoogste responspercentage. Op de derde plaats staat Hogeschool West-Vlaanderen met
11%. Deze drie scholen liggen geografisch ver van elkaar. De respondenten komen vooral uit
de richtingen Toegepaste Informatica en Elektronica-ICT.
28

Welke objectgeoriënteerde programmeertalen zag/ziet u op hogeschool of universiteit?


Figuur 12 Enquête: Welke talen zag je?
Java is de programmeertaal die het meest gegeven wordt in de hogescholen en
universiteiten gevolgd door JavaScript en C# (Figuur 12). Slechts 8 mensen zagen Objective-C
op school, wat toch opmerkelijk is als je vergelijkt met de grafieken in hoofdstuk 3 waar
Objective-C vrij hoog scoort in populariteit door iOS en Mac OS X. Deze taal heeft qua
syntaxis wat weg van Smalltalk en wordt gebruikt voor het ontwikkelen van applicaties voor
iOS en Mac OS X. De reden waarom deze taal weinig wordt gegeven, zal te maken hebben
met de syntax.

29

In welke objectgeoriënteerde programmeertalen heb je ervaring?


Figuur 13 Enquête: Programmeertaal ervaring
Deze grafiek (Figuur 13) stemt overeen met de vorige grafiek (Figuur 12) van de
programmeertalen die ze zagen op school. Toch zijn er enkele uitzonderingen. Niemand van
onze respondenten heeft ervaring met Eiffel. Dit is geen verassing aangezien de taal niet
eens voor komt in de top 100 van TIOBE.
Ruby en Python worden minder gegeven op hogescholen en universiteiten. Er zijn meer
respondenten die er ervaring mee hebben.

30

Welke objectgeoriënteerde programmeertalen zou je nog willen leren?


Figuur 14 Enquête: Te leren programmeertalen
Van al onze respondenten willen 82 respondenten C++ leren (Figuur 14). Dit komt
hoofdzakelijk omdat de respondenten deze taal niet zagen op school en/of er weinig
ervaring mee hebben. Het kan ook andere redenen hebben zoals snelheid en
geheugengebruik waar C++ geschikter voor is dan Java (onlyjob, 2011).
Daarnaast willen 69 respondenten Python leren, een server-side scripttaal voor websites en
mobiele applicaties. Python was in februari 2011 zeer populair (Figuur 15), maar is sindsdien
iets minder populair geworden.
31


Figuur 15 Programming Community Index Python

Hetzelfde verhaal bij Ruby (Figuur 16) en PHP (Figuur 17), die net zoals Python scripttalen
zijn. In december 2008 was Ruby het populairste. Deze taal stond toen op positie 8 in de
ranking, maar sindsdien was er een daling in populariteit. Ruby wordt vooral gebruikt voor
webgebaseerde applicaties zoals Ruby on Rails (een web development framework). Bekende
websites zoals GitHub, Twitter, Soundcloud, Twitch en Groupon maken hier gebruik van. Via
‘builtwith.com’ kan je nagaan welke programmeertaal/framework er wordt gebruikt op een
specifieke website.

32


Figuur 16 Programming Community Index Ruby

Figuur 17 Programming Community Index PHP
Slechts 5% wil Java leren, dit is te verklaren omdat de meesten deze taal al zagen op school
of hier al ervaring in hebben. Voor hen is het dus niet meer nodig deze taal te leren.
33

Objective-C scoort hoog omdat deze taal weinig wordt gegeven aan hogescholen en
universiteiten. Met de opmars van de iPhone en iPod is het interessant om deze taal te leren
voor het ontwikkelen van mobiele applicaties voor iOS.
Respectievelijk 1 en 2%, wil nog Eiffel en Smalltalk leren. De populariteit van beide talen is
vrij laag bij onze respondenten. Ook globaal gezien zijn deze talen niet populair (zie
hoofdstuk 3).
Hoelang heb je programmeerervaring?


Figuur 18 Enquête: Programmeerervaring
Omdat de meeste van onze respondenten studenten zijn, hebben ze maar 1 tot 5 jaar
programmeerervaring (Figuur 18). Hiervan heeft 22% minder dan 1 jaar ervaring en 13%
tussen de 5 en 10 jaar ervaring. De onderzoeksvraag die we in dit hoofdstuk proberen op te
lossen, is welke programmeertaal het meest toegankelijk is voor beginnende programmeurs.
Deze studenten zijn beginnende programmeurs waardoor het antwoord op deze
onderzoeksvraag niet in gedrang komt.
Welke van volgende programmeertalen is volgens jou de populairste?


Figuur 19 Enquête: Populaire talen
34

Meer dan de helft vindt dat Java de populairste programmeertaal is (Figuur 19). Dit
suggereert dat in Vlaanderen Java gepercipieerd wordt als een populaire taal. Op de tweede
plaats staat C# en de derde plaats PHP. Ook uit de populariteitsgrafieken uit hoofdstuk 3
blijkt dat Java bovenaan staat als populairste programmeertaal. Een groot verschil merken
we bij Objective-C. Slechts 2 mensen vinden dit de populairste programmeertaal hoewel het
de tweede populairste objectgeoriënteerde programmeertaal is volgens TIOBE en vierde
populairste bij de verkoop van boeken.
Wat is volgens jou de beste programmeertaal om het objectgeoriënteerde
programmeerparadigma te leren kennen?


Figuur 20 Enquête: Beste taal om te leren
Ruim 58% vindt Java de beste taal om het objectgeoriënteerd programmeerparadigma te
leren kennen (Figuur 20). Opmerkelijk is dat 177 respondenten Java op school zagen, maar
toch vinden slechts 113 respondenten deze taal de beste om het objectgeoriënteerd
programmeerparadigma te leren.
Als tweede staat C#, dewelke syntactisch vergelijkbaar is met Java. Bij het vergelijke van de
syntax wordt duidelijk dat sommige woorden verschillen, maar de structuur blijkt
fundamenteel hetzelfde. Het verschil tussen Java en C# is niet het onderscheid tussen twee
talen, maar eerder tussen twee dialecten (Edwards, 2013). Op de derde plaats komt C++.
De andere programmeertalen hebben een percentage gelijk aan of kleiner dan 4%.

35

Wat is de eerste objectgeoriënteerde taal die je geleerd hebt?





Figuur 21 Enquête: Wat is de eerste objectgeoriënteerde taal die je geleerd hebt?
De helft van de respondenten leerde Java als eerste taal (Figuur 21). C# en C++ staan op de
respectievelijk tweede en derde plaats. De respondenten hadden de mogelijkheid een
programmeertaal te geven die niet in de lijst was opgenomen. Bij de overige
programmeertalen merken we op dat Visual Basic en VB.NET vaak genoemd worden. Deze
komen minder voor in de populariteitsgrafieken van hoofdstuk 3.
Bij 53% van de respondenten is de taal die ze het eerst geleerd hebben en de beste taal om
het objectgeoriënteerde programmeerparadigma te leren kennen hetzelfde.
Wat is uw favoriete objectgeoriënteerde programmeertaal?


36

Figuur 22 Enquête: Favoriete taal?
De favoriete taal bij onze respondenten is Java gevolgd door C#, PHP en C++ (Figuur 22). Bij
43.6% van de respondenten is hun favoriete taal dezelfde als de taal die ze het eerst hebben
geleerd.
Welke van volgende programmeertaal gebruik je het meest?


Figuur 23 Enquête: Welke gebruik je het meest?
Ruim de helft van de respondenten gebruikt Java het meest (Figuur 23). Daarna komt C# en
PHP. 71% van de respondenten koos als favoriete programmeertaal dezelfde als de
programmeertaal die ze het meest gebruiken.
Hoe vaak programmeer je in deze programmeertaal?


Figuur 24 Enquête: Hoe vaak programmeer je in deze programmeertaal?
Deze vraag gaat verder op de vorige vraag. Bijna de helft van de respondenten
programmeert elke week en 36% programmeert elke dag in de taal die hij het meest
gebruikt (Figuur 24).

37

Tabel 1 Hoe vaak programmeren de respondenten in hun taal die ze het meest gebruiken

Elke
dag
Elke
week
Elke 2-3
weken
Elke
maand
Elke 2-3
maand
Minder
dan 1 keer
per jaar Totaal
Studenten (aantal) 43 81 8 9 4 5 150
Werknemers (aantal) 28 7 3 3 2 0 43
Werkzoekenden
(aantal) 0 1 0 1 0 0 2
Studenten (%) 29% 54% 5% 6% 3% 3% 100%
Werknemers (%) 65% 16% 7% 7% 5% 0% 100%
Werkzoekenden (%) 0% 50% 0% 50% 0% 0% 100%

De meerderheid van de studenten (54%) programmeert elke week in de taal die ze het
meest gebruiken (Tabel 1). Bij de werknemers programmeren ze meer, 65% programmeert
elke dag terwijl dit bij studenten slechts 29% is. Een verklaring hiervoor kan zijn dat sommige
werknemers mogelijks dagelijks programmeren in het kader van hun job.
Hoe zou u uw kennis van deze programmeertaal omschrijven?


Figuur 25 Enquête: Kennis programmeertaal
Hun kennis van de taal die ze het meest gebruiken omschrijven de meeste als 7 op 10 (Figuur
25).
38

Vind je het makkelijk om in deze programmeertaal code te schrijven?


Figuur 26 Enquête: Makkelijkheid
Van de respondenten vindt 73% het gemakkelijk om in deze programmeertaal code te
schrijven, 15% vindt het moeilijk en de rest heeft geen mening (Figuur 26).
Op 4 respondenten na vindt iedereen het gemakkelijk om informatie te vinden over de
programmeertaal die ze het meest gebruiken. Dit is niet onlogisch omdat er een ruime keuze
is waar je informatie kan opzoeken zoals het web, boeken, artikelen, ...
In tabel 2 zien we dat 73% het makkelijk vindt om in C++ te programmeren en 86% in C#.
66% van de respondenten vindt het makkelijk om in Java te programmeren, 23% niet
makkelijk en 11% heeft geen mening.
Tabel 2 Vergelijking talen - makkelijkheid
C++ C# Java PHP Python Ruby JavaScript
Ja (aantal) 8 30 68 24 3 1 4
Nee (aantal) 1 0 24 2 0 0 1
Geen mening
(aantal) 2 5 11 2 0 0 2
Ja (%) 73% 86% 66% 86% 100% 100% 57%
Nee (%) 9% 0% 23% 7% 0% 0% 14%
Geen mening (%) 18% 14% 11% 7% 0% 0% 29%

4.2 VERGELIJKING RESULTATEN ENQUÊTE MET POPULARITEITSGRAFIEKEN
Als alle enquêteresultaten worden gecombineerd en gekeken wordt welke
programmeertalen het meest werden gegeven als antwoord, komen we uit op JavaScript,
PHP, C# en Java. Indien we dit vergelijken met de RedMonk Programming Language Rankings
(die gebaseerd is op GitHub en Stack Overflow) van januari 2014 zien we dat deze vier talen
39

bovenaan staan. In vergelijking met de andere indicatoren uit hoofdstuk 3, zoals de TIOBE
index of PyPL index, zijn er slechts kleine verschillen. Hieruit kunnen we besluiten dat de
enquête een goede vertoning geeft van de werkelijkheid.
Hieronder wordt de RedMonk ranking van januari 2014 weergegeven. De cijfers tussen
haakjes tonen de verschillen met de ranking van juni 2013:
1. JavaScript (+1)
2. Java (-1)
3. PHP
4. C# (+2)
5. Python (-1)
6. C++ (+1)
7. Ruby (-2)
8. C
9. Objective-C
10. CSS (nieuw)


40

5 OVERZICHT VAN DE GEKOZEN PROGRAMMEERTALEN
In hoofdstuk 3 werden grafieken van verschillende indicatoren voor de populairste
programmeertalen weergegeven. Omdat deze grafieken geen eenduidig antwoord geven en
er getwijfeld kan worden aan de betrouwbaarheid van deze grafieken, wordt de keuze van
de vier programmeertalen die onderzocht zullen worden, gebaseerd op resultaten van de
enquête. Bij de populariteitsgrafieken bleek echter dat Java zeer populair was, deze
programmeertaal wordt dus zeker opgenomen. Wanneer alle enquêteresultaten worden
bekeken, kan geconcludeerd worden dat Java, JavaScript, PHP en C# het meest werden
gegeven als antwoord. Dit maakt dat er wordt gekozen voor deze vier talen.
5.1 JAVA
5.1.1 Geschiedenis
In 1991 kreeg een groep ingenieurs (onder leiding van James Gosling) van het bedrijf Sun
Microsystems de taak om een programmeertaal te ontwikkelen die zou worden gebruikt in
consumentenproducten (TV adapters,…). Ze wilden een kleine taal creëren dat zeer efficiënt
was, omdat deze zou gebruikt worden voor apparaten die geen krachtige processor hadden.
De taal diende ook platformonafhankelijk te zijn omdat elke fabrikant andere hardware
gebruikte, "Write Once, Run Anywhere". Hierdoor besloot men de code te compileren naar
bytecode (dewelke hardware onafhankelijk is) om dan uit te voeren in een virtuele machine
(Paul Carter, 1997).
De ontwikkelaars baseerden hun nieuwe taal op C++ omdat Sun gebruik maakte van Unix op
hun computers. Aangezien men een taal wou dat objectgeoriënteerd is, werd niet gekozen
voor C. De nieuwe taal kreeg de naam ‘Oak’, maar dit veranderde snel, aangezien er al een
programmeertaal bestond met diezelfde naam. De naam werd vervolgens veranderd naar
‘Java’.
In 1995 kwam de eerste publieke versie van Java. Het World Wide Web begon meer aan
populariteit te winnen en men besefte dat de taal ook hier goed gebruikt kon worden,
waardoor werd overgegaan van elektronische apparaten naar een webomgeving. Doordat
een Java-programma als applet veilig in een webpagina ingebed kon worden, werd Java snel
populair.
41

De applicaties kunnen op 2 manieren uitgevoerd worden:
Standalone: Het programma wordt op een computer uitgevoerd.
Applets: Het programma wordt in de browser uitgevoerd. Het draait in een beperkte JVM
dat men een sandbox omgeving noemt. In deze omgeving kan men geen bestanden
schrijven of lezen van de computer.
In 2006 gaf Sun een stuk van de code van Java vrij als Open Source Software (OSS) onder de
GPL-licentie. Een jaar later, in 2007, werden de laatste delen, met enkele uitzonderingen,
van de code vrijgegeven onder dezelfde licentie.
Toen Google het besturingssysteem Android voor mobiele apparaten op de markt bracht,
werd Java populairder bij mobiele softwareontwikkelaars. Applicaties (apps) voor Android
worden voornamelijk ontwikkeld in Java door gebruik te maken van de Android SDK
(Software Development Kit) (Flanagan, 1997; Paul Carter, 1997).
5.1.2 Uitvoering
Wanneer een Java-project wordt gebuild zullen de bronbestanden (*.java) omgevormd
worden naar Java bytecode (*.class bestanden). Zo zal de high-level code een stuk dichter
staan bij de machinetaal. Wanneer je een lagere programmeertaal hebt, zal dit
gemakkelijker en sneller zijn voor de computer maar minder leesbaar voor programmeurs.
Wanneer je een Java-programma uitvoert, zal het eigenlijk de Java bytecode doorsturen naar
de JVM. De interpreter (hoofdstuk 1.3.2) zal de bytecode compileren at-runtime.

Een voordeel voor een programma dat in de JVM wordt uitgevoerd, is dat de beveiliging
verbetert. Een programma zal het besturingssysteem storen veel moeilijker of corrupte data
laten schrijven. Het nadeel van een JVM is dat er niet één versie bestaat, maar verschillende.
Oracle heeft zijn eigen versie van de JVM, maar ook andere mensen kunnen hun eigen versie
bouwen. Een probleem zou kunnen zijn dat de applicatie wel op één JVM draait maar niet op
een andere (Slangen, 2012).

5.1.3 Toekomst
Het succes van de taal is niet alleen door eigenschappen van de taal, maar eerder door de
bibliotheken die beschikbaar zijn voor de taal. Java wordt ondersteund door 's werelds
42

grootste en belangrijkste technologische bedrijven en organisaties zoals Oracle, Google,
IBM,… Dit bevordert de toekomst van de taal aangezien veel kan worden geïnvesteerd in de
taal om ze beter te maken.

Android geeft een boost aan de taal in de mobiele wereld omdat de apps op Android
voornamelijk in Java zijn ontwikkeld. Omdat de mobiele wereld zeer snel groeit, zullen er
verschillende cursussen en opleidingen aankomen om Java voor mobiele applicaties aan te
leren. De platformonafhankelijkheid is ook zeer positief bij Java. Elk programma zal draaien
op goedkope smartphones en high-end servers. Ook een belangrijk punt is dat Java open
source is sinds 2006. Zo kunnen ontwikkelaars de broncode gemakkelijk bekijken en
aanpassen. Je kan dit vergelijken met crowdsourcing. Java moet niet alleen worden gezien
als een programmeertaal, maar eerder als een platform. Er zijn verschillende talen die op de
JVM draaien, zoals Clojure en Scala. Wanneer al deze punten in acht worden genomen,
wordt duidelijk dat Java een zeer positieve toekomst in de IT-wereld tegemoet gaat
(Stephen, 2010).
5.2 C#
5.2.1 Geschiedenis
C# verscheen in 2000 en werd ontworpen en uitgebracht door Microsoft (Hamilton, 2008). In
januari 1999 stelde Anders Hejlsberg een nieuw team samen om een nieuwe taal te
ontwikkelen. Origineel was de naam van de taal ‘COOL’, wat stond voor ‘C like Object
Oriented Language’. Hun bestanden hadden een extensie .cool en dat vonden ze leuk. Spijtig
genoeg kon deze naam niet worden gebruikt door verschillende trademark problemen. De
nieuwe naam C# (C sharp) is geïnspireerd door de naam C++. Deze stond voor een
toeneming (increment) van C, C# staat dus voor nog een toeneming van C++ dus 4 keer het
plus teken (Hamilton, 2008).
In een interview door Computerworld.com vertelde Anders Hejlsberg over zijn visie van het
ontwerp van C#. Het doel was om een eerste klasse moderne taal te maken, die als
doelgroep ervaren programmeurs heeft. C# was eveneens zo ontworpen zodat het
gemakkelijk nieuwe versies kon uitbrengen zonder de vorige oude code te breken (Hamilton,
2008; Yahl, 2012).
43

5.2.2 Uitvoering
Om een .cs bestand uit te voeren, zal je dit eerst moeten compileren. Je kan verschillende
compilers gebruiken, maar de belangrijkste is degene die in Visual Studio wordt gebruikt.
Wanneer je compileert met het .NET framework, wordt er niet meteen een OS specifieke
native code aangemaakt. Men compileert naar een CIL (Common Intermediate Language)
code. Deze code is niet besturingssysteem specifiek en is niet specifiek naar C#. In andere
.NET talen, zoals Visual Basic .NET, zal deze ook compileren naar CIL. Deze compilatiestap
wordt uitgevoerd door VS wanneer je C# applicaties maakt. Na deze taak wordt de JIT (Just-
In-Time) compiler gebruikt, deze zal de CIL compileren naar een native code dat OS en
machine architectuur specifiek is. Pas vanaf deze stap kan het OS de applicatie uitvoeren. De
naam Just-In-Time betekent dat de CIL code pas gecompileerd wordt wanneer het nodig is.
Vroeger was het noodzakelijk om de code te compileren naar verschillende
besturingssystemen en CPU architecturen. Dat werd gedaan om de code te optimaliseren
zodat deze sneller zou draaien op elk platform. Tegenwoordig gebruiken JIT compilers de CIL
code (dat platformonafhankelijk is).
Wanneer een applicatie wordt gecompileerd, zal het een CIL code aanmaken. Deze wordt
opgeslagen als een Assembly bestand. Deze bestanden hebben een uitvoerbaar bestand
(.exe) en een bibliotheek bestand (.dll). De CIL bestanden kunnen ook meta data bevatten,
alsook optionele bestanden zoals geluidbestanden en afbeeldingen. Aan de hand van de
meta-informatie maken we het volledig zelfomschrijvend. Dit betekent dat er geen andere
informatie nodig is om het Assembly bestand te gebruiken, zo kunnen we problemen
vermijden, zoals het falen van noodzakelijke data toe te voegen aan het systeem register,…
Dit betekent eveneens dat wanneer je een applicatie op een andere een computer wilt laten
draaien, je gewoonweg de bestanden verplaatst en uitvoert. Een CLR (Common Language
runtime) kan enigszins worden vergeleken met de JVM. De CLR zal je applicatie beheren
zoals het geheugen toekennen, beveiliging beheren, debugging,… Hieronder worden
verschillende afbeeldingen getoond met de stappen om een C# programma uit te voeren
met het .NET framework (Figuur 28-31) (Watson, 2010).
44


Figuur 27 Originele code

Figuur 28 Code naar Assembly

Figuur 29 Assembly naar Native code

Figuur 30 Native code in de CLR
5.2.3 Toekomst
Sinds de eerste release van C# is er veel veranderd. De taal heeft veel belangrijke features
gekregen zoals lambda's, ook anonieme functie genoemd (dit is een lokale functie die wordt
gebruikt als argumenten) en async, waarbij de applicatie kan verder werken zonder dat het
moet wachten op een bepaald element.
45

Maar vooral het open source project ‘Mono’ is gunstig voor de taal. Mono
maakt het mogelijk dat C# niet alleen op .NET applicaties kan draaien.
Wanneer je op het web, iOS, Android, Linux, Unix, OS X of Windows wilt
ontwikkelen met C#, kan dit met Mono en het .NET framework. Mono zit
steeds wat achter op de officiële release, waardoor niet alle
functionaliteiten worden ondersteund. Met MonoTouch kan je
gemakkelijk mobiele apps ontwikkelen die cross-platform zijn. Ook gebruikt de Unity game
engine C#, wat het weer veelbelovend maakt aangezien de engine ook
platformonafhankelijk is.
Microsoft wilt de standaard compiler (hoofdstuk 1.3.1) veranderen naar een ‘compiler als
een dienst’. Microsoft Roslyn is dit nieuwe project. Roslyn is een nieuwe set open source
compilers en code analyse API’s voor C# en Visual Basic .NET. (Hejlsberg, 2011)
Ontwikkelaars krijgen toegang tot de Roslyn API’s zodat ze elke stap van de compiler kunnen
bekijken en hun applicatie kunnen analyseren, debuggen en optimaliseren. Sinds 3 april
2014 is Microsoft Roslyn open source met de Apache 2.0 licentie (Lippert, 2014; McAllister,
2013).

Figuur 31 Mono logo
46

5.3 JAVASCRIPT
5.3.1 Geschiedenis
JavaScript werd origineel ontworpen door Brendan Eich, die bij Netscape
werkte. Brendan ontwierp de scripttaal in 10 dagen. De oprichter van
Netscape besloot de nieuwe taal Mocha te noemen. Daarna veranderde
de naam naar LiveScript. Later in hetzelfde jaar kwam er weer een
naamswijziging omdat Netscape een trademark licentie kreeg van Sun.
LiveScript kreeg de nieuwe naam JavaScript door de ondersteuning van
Sun Microsystems.
JavaScript is een interpreted taal die sterk objectgeoriënteerd is en op verschillende
platformen kan worden uitgevoerd. JavaScript wordt samen met HTML bestanden gebruikt.
JavaScript kan dus niet op zichzelf worden gebruikt. Het doel van JavaScript was om een
lichte interpreted taal te ontwikkelen die dient als aanvulling voor andere talen, zoals Java
en Visual Basic. Vandaag is JavaScript de meeste gebruikte taal op het web. Oracle bezit de
rechten van JavaScript samen met Mozilla die verschillende bekende programma’s heeft
zoals Thunderbird en Firefox (Neer, 2013).
5.3.2 Uitvoering
Tegenwoordig wordt JavaScript vooral uitgevoerd aan de hand van engines (een programma
dat broncode uitvoert). Een JavaScript engine kan op meerdere manieren worden gebruikt,
maar wordt vooral in een web browser gebruikt. Een JavaScript engine is ontworpen om snel
grote JavaScript applicaties uit te voeren. Er zijn verschillende belangrijke engines:
 V8 (Google Chrome)
 JavaScriptCore ( Safari)
 SpiderMonkey (Firefox)
V8 JavaScript engine van Google zal de JavaScript broncode compileren in machine code en
meteen uitvoeren. Er is geen byte code en geen interpreter.
JavaScriptCore is een C-gebaseerde API die wordt gebruikt in OSX en iOS7. JavaScriptCore
geeft de ontwikkelaars diepe toegang tot de volledige JavaScript runtime van Objective-C.
Figuur 32 JavaScript
Logo
47

JavaScript draait hier in een virtuele machine. Je kan verschillende elementen gebruiken
zodat je ondersteuning hebt van onder andere multithreading.
SpiderMonkey is de eerste JavaScript engine dat gemaakt werd. Deze werd geschreven door
Brendan Eich. Deze engine wordt in verschillende applicaties gebruikt zoals Firefox,
Thunderbird, GNOME desktops en Adobe Dreamweaver. SpiderMonkey is geschreven in
C/C++ en bevat een interpreter (Google, 2014; Meerdere, 2014; Mozilla, 2014).
5.3.3 Toekomst
JavaScript is onmisbaar op de browser, deze domineert bijna alles wat een cliënt computer
doet. De servers zullen nu ook JavaScript omarmen met de service-side Node.js. JavaScript
zal zeker ook dominanter worden op andere gebieden. Bij smartphones worden er vooral
apps gemaakt door de native taal die is opgelegd door de fabrikant. Objectice-C voor iOS,
Java voor Android, C# voor Windows phone. Nieuwe mobiele ontwikkelaars zullen betere
prestaties en crossplatform halen uit HTML5 apps. Google duwt JavaScript vooruit door hun
eigen V8 JavaScript engine. Browsers zullen elkaar concurreren aan de hand van snelheid.
JavaScript zal hierbij zeker en vast helpen. JavaScript is nog niet op zijn hoogtepunt, de
browsers zullen verbeteren en zo zal JavaScript dit ook doen (Walsh, 2013; Wayner, 2014).
5.4 PHP
5.4.1 Geschiedenis
PHP is vandaag gekend als de opvolger van PHP/FI. In 1994 heeft
Rasmus Lerdorf de eerste code geschreven voor PHP, toen nog
een eenvoudige set van Common Gateway Interface (CGI)
binaries, geschreven in C. Het project was origineel voor het
tracken van de bezoekers van zijn eigen website. Hij noemde de groep scripts ‘Personal
Home Page Tools’ ofwel PHP Tools. Na een verloop van tijd werden er meer functionaliteiten
verwacht, daarom schreef Rasmus PHP tools die een grote omvang van code had en meer
mogelijkheden. Deze versie had verschillende nieuwe features, zoals database interactie en
meer. In juni 1995 heeft Rasmus de broncode van PHP Tools publiek gemaakt zodat andere
ontwikkelaars deze kon gebruiken en verbeteren (Lerdorf, 1995)
Figuur 33 PHP Logo
48

Rond september 1995 heeft hij PHP tools uitgebreid en de naam ‘PHP’ veranderd naar FI
(Forms Interpreter). Deze nieuwe versie had Perl-achtige variabelen, automatische
interpretatie van form elementen en HTML syntax. In oktober 1995 had Rasmus een nieuwe
herschreven versie van de code uitgebracht. Ook bracht hij de naam ‘PHP’ terug, de
volledige naam was ‘Personal Home Page Construction Kit’. De taal leek op de C-structuur
zodat het gemakkelijker is voor ontwikkelaars die programmeren met C, Perl of gelijkaardige
talen. De code kreeg weer een volledig opknapbeurt in april 1996. Deze versie bracht PHP als
een eigen programmeertaal. Er was ondersteuning voor DBm, mSQL, Postgres95 databases,
cookies, user-gedefinieerde functies en nog veel meer. Rond 1997-1998, had PHP/FI een
paar duizend gebruikers. Volgens een onderzoek van Netcraft (Internet servicse bedrijf)
hadden bijna 60 000 domeinen de header ‘PHP’. Dit was rond de 1% van alle domeinen in
die tijd. De dag van vandaag is PHP een onmisbare programmeertaal in de web wereld
(PHP.net, 2014).

5.4.2 Uitvoering
PHP wordt op de server uitgevoerd waar de website gehost is. Het kan dus niet in de
browser of op de computer van de cliënt worden uitgevoerd. De broncode wordt uitgevoerd
op de server, het resultaat van het programma zie je in de browser.
5.4.3 Toekomst
Er zijn verschillende nieuwe projecten bezig die PHP kunnen verbeteren. HHVM (HipHop for
PHP), ontworpen door Facebook, is er één van. HipHop werd origineel bedoeld om de data
op Facebook te bewaren, aangezien dit moeilijk was door de gigantische hoeveelheden. Het
werd al snel duidelijk dat men ook HHVM buiten Facebook kon gebruiken om PHP
applicaties te versnellen. HHVM is een open source virtuele machine dat programma’s kan
uitvoeren in Hack en PHP. HHVM gebruikt een just-in-time (JIT) compilatie om zo superieure
prestaties te bereiken met behoud van de flexibiliteit die PHP-ontwikkelaars gewoon zijn
(Proctor, 2012).
49

6 ALGEMENE VERGELIJKING
Tabel 3 Eigenschappen programmeertalen
Java C# PHP JavaScript
Gebruiksdoel Application,
business,
client-side,
general,
server-side,
web
Application, RAD,
business, client-side,
general, server-side,
web, robotics
Server-side,
web, application
web
Client-side,
server-side, web
Imperative    
Object-oriented    
Reflective    
Functional    
Generic    
Event-Driven    
Andere paradigms Concurrent Structured,
Concurrent
 Prototype-based
Gestandariseerd? Facto
standard
2000, ECMA, ISO Nee 1997, ECMA

De vier gekozen talen zijn imperatief (hoofdstuk 1.2.1), objectgeoriënteerd (hoofdstuk 1.2.2
reflectief (hoofdstuk 1.2.3) ) en event-driven (hoofdstuk 1.2.6). Deze laatste kan gebruikt
worden voor het observeren en/of wijzigen van de structuur van het programma tijdens de
uitvoering.
Java is niet specifiek ontworpen om functioneel programmeren (hoofdstuk 1.2.4) te
ondersteunen, het is wel mogelijk met bibliotheken zoals LambdaJ, Functional Jave, Google
guava,...
C# ondersteunt functioneel programmeren door type inference (mogelijkheid om
automatisch het datatype van een expressie te bepalen), anonymous functions (een functie
50

die gedefinieerd wordt en mogelijk aangeroepen zonder dat ze gebonden is aan een
identifier) en Language Integrated Query (alternatief voor XPath, XQuery en SQL).
JavaScript is geen echte functionele taal zoals C# maar ondersteunt enkele typische
kenmerken van een functionele taal. Hierdoor kan je functioneel programmeren in
JavaScript, bijvoorbeeld met de jQuery-bibliotheek (Esposito, 2010).
Java en C# ondersteunen generiek programmeren, waar programma's worden geëvalueerd
tijdens het compileren. De twee scripttalen PHP en JavaScript ondersteunen deze niet.


51

7 VERGELIJKING VAN DE THEORETISCHE ASPECTEN VAN JAVA,
C++, PHP EN JAVASCRIPT
7.1 INLEIDING
Er zijn heel wat verschillen tussen de verschillende talen. Alvorens een vergelijking te maken,
wordt eerst bepaald welke concepten belangrijk zijn. De onderzoeksvraag die met dit deel
wordt beantwoord, is welke taal het meeste eenvoudig is om de essentiële elementen van
objectgeoriënteerd programmeren aan te leren.
In het artikel (Armstrong, 2006) focussen ze zich op
de fundamentele concepten van objectgeoriënteerd
programmeren. Objectgeoriënteerd programmeren
werd in de late jaren 1960 geïntroduceerd (Simula
programmeertaal, zie hoofdstuk 1.1). Een belangrijk
struikelblok is het aanleren van de
objectgeoriënteerde aanpak. Het aanleren van
objectgeoriënteerd (OO) programmeren kan moeilijk
zijn omdat we de fundamentele concepten nog niet
goed begrijpen.
Omdat er geen algemene overeenstemming is rond
de definitie van de essentie van OO, hebben
verscheidene auteurs gepleit voor een
overeenkomst (Rosson & Alpert, 1990). Terwijl er
werd geprobeerd om tot een dergelijke
overeenkomst te komen, is er nog altijd geen
akkoord. Er is dus geen exacte zekerheid wat de
fundamentele concepten van OO zijn (Henderson-
Sellers, 1992).
Het doel van het artikel (Armstrong, 2006) is
tweedelig, namelijk de fundamentele concepten identificeren en beschrijven alsook bepalen
Figuur 34 Frequentie concepten
52

hoe deze concepten passen tot een samenhangend geheel.
Om die vragen te beantwoorden werden allerlei bronnen onderzocht die het keyword
‘object-oriented development’ bevatten en verschenen van 1999 tot 2005. Verschillende
bronnen (artikelen, magazines, boeken en conferenties) en adviezen van professoren
(informatica) werden onderzocht. Van de 239 bronnen, bleek uit 88 bronnen dat er een
specifieke set van concepten nodig was, voordat men het OO kan noemen. Deze 88 bronnen
werden gebruikt en van de 39 concepten werden er 8 vastgesteld in de meerderheid van de
bronnen. Figuur 35 toont aan hoe frequent deze concepten voorkomen. De meest frequente
is inheritance, gevolgd door object, class, encapsulation, method, message passing,
polymorphism en abstraction. Deze concepten hebben een percentage boven 50% en zijn
belangrijk in het aanleren van een nieuwe taal. De belangrijkste fundamentele concepten
zullen verder worden besproken en vergeleken in de verschillende programmeertalen.
Niet al deze fundamentele concepten worden in elke objectgeoriënteerde programmeertaal
gebruikt. Class-based programming maakt bijvoorbeeld gebruik van encapsulation en
inheritance, voorbeelden van class-based programming zijn Smalltalk, PHP, C++, Java, C# en
Objective-C. Anderzijds is er prototype-based programming (hoofdstuk 1.2.7), die gebruik
maakt van een proces dat bestaande objecten kloont die dienen als prototype. De bekendste
taal die hiervan gebruik maakt is JavaScript.
7.2 INHERITANCE
7.2.1 Algemeen
Inheritance of overerving is een term die gebruikt wordt bij het objectgeoriënteerd
programmeren. Bij overerving hebben verschillende soorten objecten een relatie met elkaar.
Bijvoorbeeld mountainbikes, racefietsen en tandemfietsen delen allemaal de kenmerken van
een fiets. Daarnaast hebben ze ook allemaal extra eigenschappen, zoals de tandem die twee
zadels moet hebben.
Overerving maakt het mogelijk dat klassen een veelgebruikte staat en gedrag kunnen
overerven van een andere klasse. In ons voorbeeld wordt fiets de superklasse van
mountainbikes, racefietsen en tandem fietsen, omdat ze alle drie eigenschappen bevatten
van fiets (Oracle, n.d.).
53

7.2.2 Vergelijken
Inheritance mag niet verward worden met subtyping. In sommige talen zijn deze hetzelfde,
in andere verschillend. Om deze twee concepten te onderscheiden, is subtyping ook gekend
als interface inheritance, terwijl inheritance zoals hier wordt besproken gekend is onder de
naam implementation inheritance.
C#, Java en JavaScript ondersteunen alleen het gebruik van single inheritance waar elke
klasse zoveel interfaces mag implementeren als hij wil. Een interface heeft een set van
methoden die opgeroepen kunnen worden op een klasse-instantie die dit implementeert
maar het levert geen gegevens, het is alleen een definitie (Microsoft Developer Network,
2003).
PHP gebruikt traits classes voor multiple inheritance functies. Dit is een klasse sjabloon
gebruikt om de staat en/of het gedrag te koppelen aan een compile-time entity, meestal een
datatype of een constante, zonder wijziging van de bestaande entiteit.
JavaScript is een prototype-gebaseerde taal (hoofstuk 1.2.7) in tegenstelling tot Java, C# en
PHP deze zijn een class-gebaseerde taal. De term instance heeft een specifieke betekenis in
de class-gebaseerde talen. Een instance is een individueel lid van een klasse. Het is een
implementatie van de klasse definitie. In JavaScript heeft het begrip instance niet deze
technische betekenis omdat er geen verschil is tussen de klassen en instances (Shiran &
Tomer, 2001).
7.3 OBJECT
7.3.1 Algemeen
Objecten zijn de basis run-time entiteiten in een objectgeoriënteerd systeem. Elk object
wordt geassocieerd met data en functies die zinvolle activiteiten op dat object uitvoeren
(Cory Janssen, 2013).
7.3.2 Vergelijken
Een object is een instantie van een klasse. Een object aanmaken is praktisch hetzelfde in elk
van deze talen. Er zijn wel een aantal verschillen. In JavaScript kan bijna alles een JavaScript
object zijn, je maakt een object aan als een soort variabele. Je zal dus nergens het woord
“class” gebruiken. Bij PHP zal elke variabele met een $-teken moeten beginnen, ook de
54

variabelen van een object. Zowel bij PHP als bij JavaScript heb je geen main() functies. Java
en C# objecten lijken het meeste op elkaar. Zowel Java, PHP als JavaScript hebben geen
mogelijkheid om een object aan te maken op de stack, ze worden dus telkens op de heap
aangemaakt. C# kan wel stack-gebaseerde types gebruiken door het ‘struct’ keyword te
gebruiken (Mozilla Developer Network, 2014b).
7.4 CLASS
7.4.1 Algemeen
Volgens Laan (2010) bestaat er veel verwarring omtrent wat de definiëring van een klasse.
Een klasse kan worden vergeleken met een bouwtekening voor een huis. In de tekening zijn
de meeste eigenschappen van het huis, zoals de gebruikte materialen en de kleuren,
vastgelegd. Ook de wijze waarop het huis wordt verwarmd is terug te vinden op de tekening:
centrale verwarming en een open haard. Een huis dat wordt gebouwd volgens de tekening is
een object. Er wordt ook wel gezegd dat het huis een instantie is. Op grond van dezelfde
tekening kunnen meerdere huizen worden gebouwd.
Een klasse is met andere woorden een beschrijving voor objecten. Een klasse kan gegevens
bevatten, maar eveneens procedures die samenwerken met die gegevens. Omdat objecten
ook procedures kunnen bevatten, kan worden gezegd dat objectgeoriënteerd
programmeren in zekere zin procedure-gericht programmeren omvat.
7.4.2 Vergelijken
Meestal zullen de verschillende talen hun eigen manier van klasse definitie implementeren,
Java verschilt van C# en PHP maar de essentiële zaken blijven hetzelfde (Furrow, 2012).
JavaScript maakt geen gebruik van een klasse zoals de andere talen. Het maakt gebruik van
functies als klasse.
Het is bijna onmogelijk om alle features van de verschillende talen te vergelijken omdat de
beschikbare bibliotheken van alle talen enorm groot zijn. Daarom beperken we ons tot
enkele features.
C# maakt het mogelijk een klasse definitie te verdelen over meerdere bronbestanden met
behulp van partial classes. Dit kan een voordeel zijn wanneer je met meerdere
programmeurs aan hetzelfde programma schrijft. In PHP, JavaScript en Java bestaat dit soort
55

klasse niet. In JavaScript bestaan er wel mogelijkheden om dit te implementeren (Nash,
2010).
In zowel C# als Java kan je gebruik maken van inner classes, waar een klasse gedefinieerd
wordt in een andere klasse. In beide talen verschillen ze wel van betekenis. In PHP en
JavaScript maken ze geen gebruik van inner classes maar er bestaan wel alternatieven om dit
te bekomen (Michaelis, 2011).
C#, Java en PHP hebben abstracte klasse. Als voorbeeld nemen we een object die we
GraphicObject noemen, dit object heeft verschillende eigenschappen zoals positie, lijnkleur
en vulkleur. Alle GraphicObjects moeten zich kunnen verplaatsen, draaien, vergroten of
verkleinen maar ze verschillen in hoe ze het doen. Dit is een voorbeeld van een abstracte
superklasse. Er zijn veel gelijkenissen en alle objecten kunnen overerven van dezelfde
abstracte superklasse, GraphicObject (Oracle, 2014).
7.5 ENCAPSULATION
7.5.1 Algemeen
Encapsulation of inkapseling betekent dat de interne representatie van een object verborgen
is buiten het object. Het is in principe het verbergen van de staat van het object met behulp
van modifiers zoals private, public, protected,… (Yaiser, 2011)
Public: Elk object heeft toegang tot de data
Protected: Het object en de objecten die overgeërfd zijn van het object kunnen aan de data.
Private: Alleen het object zelf kan aan de data
7.5.2 Vergelijken
C# heeft vijf access modifiers voor class members: private, protected, internal, protected
internal en public. Private, protected en public hebben dezelfde eigenschappen als in de
andere talen.
Bij internal is een member alleen toegankelijk door code in hetzelfde assembly bestand en
niet vanuit een ander. Dit betekent dat ze in dezelfde DLL (Dynamic Link Library) of
uitvoerbaar bestand (*.exe) moeten zijn.
56

Protected internal betekent dat een member alleen toegankelijk is door code in hetzelfde
assembly bestand waar het gedeclareerd is of een afgeleide klasse in een andere assembly
bestand (Microsoft Developer Network, 2014a).
7.6 METHOD
7.6.1 Algemeen
Een method, ook procedure of operation genoemd, is een subroutine die geassocieerd wordt
met een object en die toegang heeft tot zijn gegevens. Methoden worden gedefinieerd in
een class. Je kan dit vergelijken met een functie van een object. Om een method op te
roepen in de verschillende talen zijn er syntactisch weinig verschillen (Microsoft Developer
Network, 2013).
7.6.2 Vergelijken
Java, C#, PHP hebben allemaal static en instance methods. Wanneer je een instance method
oproept moet er eerst een instantie van een class bestaan. Bij een static method is dit niet
nodig. In JavaScript bestaat er geen term static, maar het is wel mogelijk door verschillende
eigenschappen en methodes toe te voegen. Dat is mogelijk omdat functies in JavaScript
gewoon objecten zijn dat eigenschappen en methodes op zichzelf hebben (Microsoft
Developer Network, 2014b).
7.7 MESSAGE PASSING
7.7.1 Algemeen
Message passing betekent dat (op een zeer abstract niveau) het fundamentele mechanisme
van de uitvoering van het programma objecten zijn die berichten van en naar elkaar
verzenden. Message passing betreft het vermelden van de naam van het object, de naam
van de functie en de informatie die verzonden moet worden (Carr, 2007).
In figuur 36 wordt een voorbeeld weergegeven. De werknemers is het object, loon het
bericht en naam de informatie die wordt doorgegeven.
57


Figuur 35 Message passing
7.7.2 Vergelijken
Alle vier talen kunnen message passing toepassen. Het bericht dat verzonden wordt met de
method kan uit verschillende types bestaan zoals objecten, strings, array, booleans, etc. Men
kan niet alleen informatie verzenden maar ook een bericht terug krijgen (afhankelijk van de
methode).
De attributen van een klasse kan je verkrijgen door de dot/punt operator te gebruiken.
Alleen bij PHP zal je de pijl ‘->’ moeten gebruiken om een variabele van een klasse te
verkrijgen.
7.8 POLYMORPHISM
7.8.1 Algemeen
Polymorphism wordt gezien als een belangrijk concept om het objectgeoriënteerd
programmeren goed tot zijn recht te laten komen. Het is nauw verwant met overerving. Een
polymorfe referentievariabele kan verwijzen naar verschillende types objecten. Wanneer
een bewerking wordt uitgevoerd op een object zal deze automatisch de juiste bewerking
voor dat object kiezen.
Een bepaalde term kan meerdere dingen betekenen. Stel u heeft een basisklasse ‘dier’, het
heeft ene methode AantalPoten(). De klassen die afgeleid zijn van de klasse ‘dier’,
bijvoorbeeld ‘kat’, zullen automatisch dezelfde methodenaam hebben, maar zullen een
andere uitvoer hebben dan bijvoorbeeld ‘spin’.
Bij polymorphisme zal dus elk object de methode AantalPoten() interpreteren op zijn eigen
manier. Met polymorphisme wordt ervoor gezorgd dat onderdelen in een programma
kunnen worden gebruikt alsof ze een abstract type zijn. Het zorgt ook voor uitbreidbaarheid.
Je kan eenvoudig nieuwe types definiëren die een implementatie zijn van een abstracte
klasse zonder teveel gevolgen voor de rest van het programma (Hanselaer & Botte, 2006).
58

7.8.2 Vergelijken
Polymorfie is in C# en Java nagenoeg hetzelfde. In Java zijn alle methodes standaard virtueel.
Bij C# zal wanneer je in de parent class het woord ‘virtual’ voor de functie schijft, het de
functie virtueel maken. Bij de child class moet je ‘override’ voor de klasse schrijven. In PHP
kan je ook polymorfie toepassen door dezelfde functienaam te gebruiken in de overgeërfde
klasse. Omdat JavaScript een prototype-gebaseerde taal (hoofdstuk 1.2.7) is, kan je geen
gebruik maken van dezelfde benadering voor polymorfie als in de andere talen. Functies in
JavaScript zijn niet gedeclareerd zoals in vele andere objectgeoriënteerde talen (Wegner,
1985).
7.9 ABSTRACTION
7.9.1 Algemeen
Abstraction betekent dat een algemene klasse, die een gemeenschappelijke interface heeft
voor verschillende systemen, wordt aanmaakt. Bijvoorbeeld wanneer een interface
geschreven wordt voor een filesystem en deze gebruikt wordt voor toegang te krijgen op
een harde schijf, netwerkdrive of Dropbox. Dan gebruikt men de onderliggende logica
zonder te weten hoe deze exact werkt. Het is een programmeertechniek die gebaseerd is op
de scheiding van interface en implementatie (Nirosh, 2013).
Een voorbeeld vanuit het echte leven is een TV, deze kan aan en uit worden gezet, van
kanaal worden veranderd, het volume kan worden geregeld,.. maar de interne details van de
TV zijn niet gekend. Een TV scheidt duidelijk de interne implementatie van de externe
interface. Je kan een TV perfect gebruiker zonder enige kennis te hebben van de interne
implementatie (Tutorialspoint, 2014). Een programmeur verbergt alles behalve de relevante
gegevens over een object om de complexiteit en efficiëntie te verminderen.
7.9.2 Vergelijken
Een class dat gedeclareerd is als abstract heeft abstracte class members. Klassen dat
gedefinieerd zijn als abstract mogen geen instance hebben van een object. Klassen die een
abstracte methode hebben moeten als abstract gedeclareerd worden. C#, Java en PHP
hebben allemaal abstracte klassen en methoden, ze hebben dezelfde syntax en
functionaliteit. JavaScript heeft dit (Olsson, 2009; Rajan, 2014).
59

8 BESLUIT
Objectgeoriënteerd programmeren is de afgelopen jaren uitgegroeid tot een invloedrijk
programmeerparadigma. Het wordt veel gebruikt in het onderwijs, maar ook in het
bedrijfsleven.
Zowel in de populariteitsgrafieken uit hoofdstuk 3, als bij onze enquête staat Java steevast
op nummer één als meest populaire objectgeoriënteerde programmeertaal. De meerderheid
van onze respondenten leerde deze taal als eerste aan en gebruiken de taal nog steeds het
meest. De ruime meerderheid (tabel 2) vindt het eenvoudig om in de taal die ze het meest
gebruiken code te schrijven en vinden het makkelijk om er informatie over te vinden.
Ook C# is populair, maar iets complexer dan Java. JavaScript en PHP, webdevelopment talen,
zijn ook populair en worden vaak gegeven in onderwijsinstellingen.
Om de essentiële elementen van objectgeoriënteerd programmeren aan te leren, wordt
best gekozen voor echte objectgeoriënteerde programmeertalen zoals Java, C# en PHP en
niet voor een prototype-gebaseerde programmeertaal zoals JavaScript. Dit omdat deze niet
rechtstreeks klassen ondersteunt. Tussen de verschillende talen zijn er ook verschillen in de
objectgeoriënteerde concepten. De ene taal heeft meer features ten opzichte van een
andere taal, maar het basisconcept blijft telkens hetzelfde.
Welke objectgeoriënteerde programmeertaal je ook als eerste taal aanleert, het zal je altijd
helpen om een andere objectgeoriënteerde taal te leren.


60

9 BIBLIOGRAFIE
Armstrong, D. J. (2006). The quarks of object-oriented development. Communications of the
ACM - Next-Generation Cyber Forensics, 49(2), 123–129. Retrieved from
http://agp.hx0.ru/oop/quarks.pdf
Arora, A., & Bansal, S. (2005). Unix and C Programming (p. 606). Laxmi Publications.
Bemer, R. W. (n.d.). A view of the history of Cobol. Honeywell Computer Journal, 130–135.
Retrieved from
http://archive.computerhistory.org/resources/text/Knuth_Don_X4100/PDF_index/k-8-
pdf/k-8-u2776-Honeywell-mag-History-Cobol.pdf
Brockmeier, J. (2012). Java Leads Programming Language Popularity - Measured by Book
Sales. Retrieved from http://readwrite.com/2012/04/10/java-leads-programming-
languag#awesm=~oEIfP6BL9CuhGZ
Capretz, L. F. (2003). A Brief History of the Object-Oriented Approach (p. 10). London, ON,
CANADA. Retrieved from http://www.engga.uwo.ca/people/lcapretz/ACM-SIGSOFT-
v2.pdf
Carbonnelle, P. (2014). PYPL PopularitY of Programming Language index. Retrieved from
https://sites.google.com/site/pydatalog/pypl/PyPL-PopularitY-of-Programming-
Language
Carr, R. (2007). Object-Oriented Programming Concepts. Retrieved from
http://www.blackwasp.co.uk/ObjectOrientedConcepts.aspx
Cory Janssen. (2013). Definition - What does Object mean? Retrieved from
http://www.techopedia.com/definition/3232/object-c
Dos Reis, G. (2005). What is Generic Programming? Retrieved from
http://lcsd05.cs.tamu.edu/papers/dos_reis_et_al.pdf
Edwards, S. (2013). Six Reasons Why You Should Learn C#. Retrieved from
https://www.opensesame.com/blog/six-reasons-why-you-should-learn-c
Esposito, D. (2010). Functional vs. Object-Oriented JavaScript Development. Retrieved from
http://msdn.microsoft.com/en-us/magazine/gg476048.aspx
Ferg, S., Commons, C., License, A., Creative, T., Attribution, C., & Ferg, S. (2006). Event-
Driven Programming : Introduction , Tutorial , History, 1–59.
Flanagan, D. (1997). Java in a Nutshell, 2nd Edition (p. 628). O’Reilly Media. Retrieved from
http://shop.oreilly.com/product/9781565922624.do
61

Freedman, A. (2014a). Definition of compiler. In The Computer Language Company.
Retrieved from http://www.pcmag.com/encyclopedia/term/40105/compiler
Freedman, A. (2014b). Definition of interpreter. In The Computer Language Company.
Retrieved from http://www.pcmag.com/encyclopedia/term/45287/interpreter
Freedman, A. (2014c). Definition of JIT Compiler. In The Computer Language Company.
Retrieved from http://www.pcmag.com/encyclopedia/term/45632/jit-compiler
Furrow, A. (2012). Why Objective-C is Hard to Learn. Retrieved from
http://ashfurrow.com/blog/2012/03/why-objective-c-is-hard
Google. (2014). V8 Dynamic Machine Code Generation. Retrieved from
https://developers.google.com/v8/design?csw=1#mach_code
Hamilton, N. (2008). The A-Z of Programming Languages: C#. Retrieved from
http://www.computerworld.com.au/article/261958/a-z_programming_languages_c_/
Hanselaer, J., & Botte, B. (2006). Vergelijkende studie van C++, C#, Java en D. Universiteit
Gent.
Hejlsberg, A. (2011). Future directions for C# and Visual Basic. Retrieved from
http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-816T
Hemmendinger, D. (2008). Machine language. Retrieved from
http://www.britannica.com/EBchecked/topic/354646/machine-language
Henderson-Sellers, B. (1992). A Book of Object-oriented Knowledge (p. 297). Englewood
Cliffs, NJ: Prentice Hall. Retrieved from
http://books.google.be/books/about/A_Book_of_Object_oriented_Knowledge.html?id
=xaZQAAAAMAAJ&redir_esc=y
Kedar, S. (2007). Programming Paradigms and Methodology (3rd ed., p. 309). Technical
Publications Pune.
Laan, G. (2010). Aan de slag met C++ (4th ed., p. 581). Sdu Uitgevers.
Lerdorf, R. (1995). Google groups. Retrieved from
https://groups.google.com/forum/#!msg/comp.infosystems.www.authoring.cgi/PyJ25g
Z6z7A/M9FkTUVDfcwJ
Lippert, R. (2014). The Past, Present, and Future of C#. Retrieved from
http://www.developer-tech.com/news/2014/jan/30/past-present-and-future-c/
Martijn Verkuil. (2011). De geschiedenis van programmeertalen. Retrieved from
http://www.computeridee.nl/nieuws/de-geschiedenis-van-programmeertalen-
infographic/
62

McAllister, N. (2013). Microsoft’s Roslyn: Reinventing the compiler as we know it. Retrieved
from http://www.infoworld.com/d/application-development/microsofts-roslyn-
reinventing-the-compiler-we-know-it-176671
Meerdere. (2014). JavaScriptCore. Retrieved from http://trac.webkit.org/wiki/JavaScriptCore
Michaelis, O. (2011). Inner “Classes” in JavaScript. Retrieved from
http://codestars.eu/2011/inner-classes-in-javascript/
Microsoft Developer Network. (2003). C# and Java: Comparing Programming Languages.
Retrieved from http://msdn.microsoft.com/en-us/library/ms836794.aspx
Microsoft Developer Network. (2013). Methods (C# Programming Guide). Retrieved from
http://msdn.microsoft.com/en-us/library/ms173114.aspx
Microsoft Developer Network. (2014a). Access Modifiers (C# Programming Guide). Retrieved
from http://msdn.microsoft.com/en-us/library/ms173121.aspx
Microsoft Developer Network. (2014b). Static and instance methods. Retrieved from
http://msdn.microsoft.com/en-us/library/aa645766(v=vs.71).aspx
Mikoluk, K. (2013). Best Programming Languages to Learn in 2013: The Elite Eight. Retrieved
from https://www.udemy.com/blog/best-programming-language/
Mozilla. (2014). SpiderMonkey. Retrieved from https://developer.mozilla.org/en-
US/docs/Mozilla/Projects/SpiderMonkey
Mozilla Developer Network. (2014a). Class-based vs. prototype-based languages. Retrieved
from https://developer.mozilla.org/en-
US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model
Mozilla Developer Network. (2014b). Working with objects. Retrieved from
https://developer.mozilla.org/en-
US/docs/Web/JavaScript/Guide/Working_with_Objects
Nash, T. (2010). Accelerated C# 2010. (J. Hassell, Ed.) (p. 609). Apress.
Nebel, J. (1998). A Brief History of Fortran. Retrieved from
http://www.ibiblio.org/pub/languages/fortran/ch1-1.html
Neer, K. (2013). History of JavaScript. Retrieved from
http://campus.murraystate.edu/academic/faculty/wlyle/415/2013/Neer.docx
Nirosh, L. W. C. (2013). Introduction to Object Oriented Programming Concepts (OOP) and
More. Retrieved from http://www.codeproject.com/Articles/22769/Introduction-to-
Object-Oriented-Programming-Concep#Generalization
63

Nygaard, K. (1978). The Development of the SIMULA Languages, 13(8). Retrieved from
http://cs-exhibitions.uni-
klu.ac.at/fileadmin/template/documents/text/The_development_of_the_simula_langu
ages.pdf
O’Grady, S. (2014). The RedMonk Programming Language Rankings: January 2014. Retrieved
from http://redmonk.com/sogrady/2014/01/22/language-rankings-1-14/
Olsson, M. (2009). A Comparison of C++, C#, Java, and PHP in the context of e-learning.
Retrieved from http://www.diva-portal.org/smash/get/diva2:510502/FULLTEXT01.pdf
onlyjob. (2011). Perl, Python, Ruby, PHP, C, C++, Lua, tcl, javascript and Java comparison.
Retrieved from http://raid6.com.au/~onlyjob/posts/arena/
Oracle. (n.d.). What Is Inheritance? Retrieved from
http://docs.oracle.com/javase/tutorial/java/concepts/inheritance.html
Oracle. (2014). Abstract Methods and Classes. Retrieved from
http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
Paul Carter. (1997). An Introduction to the Java Programming Language History of Java
Basics of Java (Vol. 1, p. 10). Retrieved from
http://www.cs.binghamton.edu/~guydosh/cs350/JavaPrimer.pdf
PHP.net. (2014). History of PHP. Retrieved from
http://be2.php.net/manual/en/history.php.php
Proctor, I. (2012). The HipHop compiler for PHP. Retrieved from
http://arxiv.org/pdf/1008.3561v1.pdf
Rajan, S. (2014). Introduction to Functional JavaScript. Retrieved from
https://medium.com/functional-javascript/introduction-to-functional-javascript-
45a9dca6c64a
Rivera, J., & Van der Meulen, R. (2014). Gartner Says Annual Smartphone Sales Surpassed
Sales of Feature Phones for the First Time in 2013. Retrieved from
http://www.gartner.com/newsroom/id/2665715
Rosson, M. B., & Alpert, S. R. (1990). The cognitive consequences of object-oriented design.
Human-Computer Interaction, 5(4), 345–379. Retrieved from
http://dl.acm.org/citation.cfm?id=1455754
Saunders, M., Lewis, P., Thornhill, A., Boqij, M., & Verckens, J. P. (2011). Methoden en
technieken van onderzoek (5th ed., p. 603). Pearson Education.
Seed, G. M. (2001). An Introduction to Object-Oriented Programming in C++ with
Applications in Computer Graphics (2nd ed., p. 1012). Edinburgh, UK: Srpinger.
64

Shiran, Y., & Tomer, S. (2001). Object-Oriented Programming with JavaScript, Part I:
Inheritance: Comparing between JavaScript and Java - Doc JavaScript.
Slangen, S. (2012). What Is The Java Virtual Machine & How Does It Work? Retrieved from
http://www.makeuseof.com/tag/java-virtual-machine-work-makeuseof-explains/
Smits, L. (2000). Programmeertalen. Retrieved from
http://docent.ehsal.be/vakken/infoburo/Theorie/Syllabus/par3_5.html
Sosnoski, D. (2003). Java programming dynamics, Part 2: Introducing reflection. Retrieved
from http://www.ibm.com/developerworks/library/j-dyn0603/
Stephen, C. (2010). Will Java still be relevant in 5 years? Retrieved from
http://programmers.stackexchange.com/questions/262/will-java-still-be-relevant-in-5-
years
Techopedia. (2014a). Fourth Generation (Programming) Language (4GL). In Techopedia.
Retrieved from http://www.techopedia.com/definition/24308/fourth-generation-
programming-language-4gl
Techopedia. (2014b). Third Generation (Programming) Language (3GL). In Techopedia.
Retrieved from http://www.techopedia.com/definition/24307/third-generation-
programming-language-3gl
Trendy Skills. (2014). Trend for programming languages. Retrieved from
http://trendyskills.com/about
Walsh, J. (2013). The Future Of The World Is JavaScript. Retrieved from
https://todaymade.com/blog/future-of-javascript/
Warren, R. (2014). Jobs Tractor language trends January 2014. Retrieved from
http://jobstractor.com/trends/January-2014
Watson, K. (2010). Introducing C#. Retrieved from http://msdn.microsoft.com/en-
us/library/hh145616(v=vs.88).aspx
Wayner, P. (2014). 12 predictions for the future of programming. Retrieved from
http://www.javaworld.com/article/2093747/java-ios-developer/12-predictions-for-the-
future-of-programming.html
Wegner, P. (1985). On Understanding Types, Data Abstraction, and Polymorphism. Retrieved
from http://lucacardelli.name/Papers/OnUnderstanding.A4.pdf
Yahl, M. (2012). History of C#. Retrieved from
http://campus.murraystate.edu/academic/faculty/wlyle/415/2012/Yahl.docx
65

Yaiser, M. (2011). Object-oriented programming concepts: Encapsulation. Retrieved from
http://www.adobe.com/devnet/actionscript/learning/oop-
concepts/encapsulation.html


66

10 LIJST VAN ILLUSTRATIES
10.1 LIJST VAN TABELLEN
Tabel 1 Hoe vaak programmeren de respondenten in hun taal die ze het meest gebruiken . 37
Tabel 2 Vergelijking talen - makkelijkheid................................................................................ 38
Tabel 3 Eigenschappen programmeertalen ............................................................................. 49

10.2 LIJST VAN FIGUREN
Figuur 1 JobsTractor advertenties van januari 2014 ................................................................ 18
Figuur 2 Trendy Skills zoekopdrachten .................................................................................... 19
Figuur 3 RedMonk Programming Languages Ranking ............................................................. 20
Figuur 4 Top 20 programmeertalen gebaseerd op boeken in 2010 en 2011 .......................... 21
Figuur 5 PyPL Index .................................................................................................................. 22
Figuur 6 TIOBE Index ................................................................................................................ 23
Figuur 7 World-Wide Smartphone Sales (%) (Rivera & Van der Meulen, 2014) ..................... 24
Figuur 8 TIOBE Index lange termijn .......................................................................................... 24
Figuur 9 Leeftijd Enquête ......................................................................................................... 26
Figuur 10 Enquête: Student, werknemer of werkzoekende .................................................... 26
Figuur 11 Enquête: Hogeschool/Universiteit ........................................................................... 27
Figuur 12 Enquête: Welke talen zag je? ................................................................................... 28
Figuur 13 Enquête: Programmeertaal ervaring ....................................................................... 29
Figuur 14 Enquête: Te leren programmeertalen ..................................................................... 30
Figuur 15 Programming Community Index Python .................................................................. 31
Figuur 16 Programming Community Index Ruby ..................................................................... 32
Figuur 17 Programming Community Index PHP ....................................................................... 32
Figuur 18 Enquête: Programmeerervaring .............................................................................. 33
Figuur 19 Enquête: Populaire talen .......................................................................................... 33
Figuur 20 Enquête: Beste taal om te leren .............................................................................. 34
Figuur 21 Enquête: Wat is de eerste objectgeoriënteerde taal die je geleerd hebt? ............. 35
Figuur 22 Enquête: Favoriete taal? .......................................................................................... 36
67

Figuur 23 Enquête: Welke gebruik je het meest? .................................................................... 36
Figuur 24 Enquête: Hoe vaak programmeer je in deze programmeertaal? ............................ 36
Figuur 25 Enquête: Kennis programmeertaal .......................................................................... 37
Figuur 26 Enquête: Makkelijkheid ............................................................................................ 38
Figuur 27 Originele code .......................................................................................................... 44
Figuur 28 Code naar Assembly ................................................................................................. 44
Figuur 29 Assembly naar Native code ...................................................................................... 44
Figuur 30 Native code in de CLR ............................................................................................... 44
Figuur 31 Mono logo ................................................................................................................ 45
Figuur 32 JavaScript Logo ......................................................................................................... 46
Figuur 33 PHP Logo................................................................................................................... 47
Figuur 34 Frequentie concepten .............................................................................................. 51
Figuur 35 Message passing....................................................................................................... 57