Visual Basic/Inleiding programmeren

Uit Wikibooks
Naar navigatie springen Naar zoeken springen

Visual Basic

Inhoudsopgave
  1. Inleiding programmeren
  2. Inleiding Visual Basic
  3. Installatie Visual Basic
  4. Visual Studio
  5. User-interface
  6. Eerste programma
  7. Toolbox en Designer
  8. Oefeningen

Waarover gaat dit handboek?[bewerken]

Dit handboek gaat over het programmeren in Visual Basic. Bij de start van dit handboek was dit versie 2012, maar dit handboek wordt doorlopend aangepast aan de nieuwste versie. Voor dit handboek wordt gebruikgemaakt van de Express-versie, omdat deze gratis verkrijgbaar is.

BELANGRIJK: dit handboek is gericht op het schrijven van desktop-applicaties, zoals je die kent van alle Windows-versies t/m Windows 7. Het programmeren van apps voor Windows 8 wordt niet in dit handboek beschreven. De achterliggende gedachte is dat iedereen vooral gewend is aan desktop-applicaties én dat "tegel"-applicaties nog in de kinderschoenen staan (dat is o.a. te zien aan de grote veranderingen in Windows 10), Ook het maken van webapplicaties wordt niet behandeld in dit handboek.

Voor het bestuderen van dit handboek heb je in principe geen programmeerervaring nodig, hoewel enige kennis over programmeren in het algemeen en wat (minimale) ervaring het wel gemakkelijker maakt. Voor degenen die graag wat achtergrond-informatie over programmeren in het algemeen en Basic in het bijzonder wordt verwezen naar het vervolg in dit deel. Als je meer ervaring hebt met programmmeren, kun je dit deel ofwel overslaan ofwel vluchtig doorlezen en vervolgens doorgaan met deel 2. Houd er wel rekening mee dat dit deel ook ingewikkelde onderwerpen behandelt zoals het Framework. Dit is gedaan om dit soort achtergrondinformatie op één plaats te verzamelen, waardoor het "echte" werk niet onderbroken wordt door dit soort informatie. Waar nodig wordt verwezen naar informatie in dit deel.

Visual Basic is slechts één van de honderden programmeertalen die bestaan. Veel programmeertalen zijn ontworpen voor een bepaald doel of om problemen op een bepaalde manier op de lossen. Daarnaast bestaan er "algemene" (all-purpose) programmeertalen, zoals Visual Basic, C, Java e.d. Deze talen hebben als kenmerk dat er in principe alles mee geprogrammeerd kan worden. Een specifiekere taal is COBOL, vooral bedoeld voor administratieve toepassingen.

In dit hoofdstuk zal eerst worden ingegaan op de werking van de computer en programmeertalen in het algemeen. Weet je al wat af van de werking van de computer en heb je al enige ervaring met programmeren, dan kun je dit hoofdstuk overslaan.

Computers en programma's[bewerken]

Inleiding computers en programma's[bewerken]

Voor de meeste mensen zijn computers in de loop der jaren gewone gebruiksvoorwerpen geworden. Dat is voor een deel te danken aan de grafische gebruikersinterface (Windows). Je ziet direct wat je doet en er zijn allerlei menu's, keuzevakjes en andere grafische of tekstuele hulpmiddelen. Veel programma's zijn zelfs zonder handleiding redelijk tot goed te gebruiken.

Maar tussen het gebruiken en het zelf maken van programma';s ligt een wereld van verschil. "Vroeger" (jaren 70, toen de PC nog niet bestond) was het zelfs zo dat er nauwelijks programma's waren. Als je toen een computer kocht, moest je zelf je programma's schrijven. En vaak was er maar één computertaal beschikbaar: BASIC. Computers en programma's waren toen nog heel "primitief", zeker als je ze vergelijkt met tegenwoordig. De schermen waren niet grafisch. Verschillende lettertypen waren er niet. Een muis was er ook nog niet. Alles was simpel, en dat gold ook voor het programmeren. Alle mogelijkheden van de taal BASIC kon je binnen één week onder de knie krijgen en in de tweede week kon je al echte programma's ontwikkelen.

Tegenwoordig is het programmeren een heel stuk ingewikkelder. Dat ligt niet aan BASIC, want aan de programmeertaal zelf is niet veel veranderd. Maar om een programma voor Windows te schrijven moet je ook gebruik kunnen maken van de grafische gebruikersinterface, de muis en misschien ook databases (bestanden waarin gegevens in tabelvorm worden bewaard). Daarom wordt nu bij elke programmeertaal een uitgebreide bibliotheek meegeleverd. Zo zijn er bijvoorbeeld stukjes programma om een waarschuwing op het scherm te laten zien of om bestanden te openen en op te slaan.

In dit handboek wordt gebruikgemaakt van de taal "Visual Basic", die ontstaan is vanuit de oude versie uit de jaren 70. Deze taal is speciaal ontwikkeld voor beginners, maar is nu zover uitgebouwd dat bijna ieder programma ermee gemaakt kan worden. De toevoeging "Visual" geeft aan dat deze taal "visueel" gericht is, wat grofweg betekent dat ze bedoeld is voor een grafisch besturingssysteem zoals Windows. Iedere versie heeft een volgnummer om de verschillende versies te onderscheiden. Vroeger was dat een gewoon volgnummer, tegenwoordig wordt het jaartal van introductie gebruikt.

Visual Basic is een onderdeel van Visual Studio, de ontwikkelomgeving die Microsoft gemaakt heeft. Deze omgeving maakt het mogelijk om op een relatief eenvoudige manier programma's te schrijven en te testen. Bij de Express-versie van Visual Basic hoort ook een Express-versie van Visual Studio. Dat Visual Studio een ontwikkelomgeving is, zie je ook doordat hiermee ook programma's in andere talen geschreven kunnen worden, zoals C#.

Computers[bewerken]

Als we over computers praten hebben we het vaak over hardware en software.

Onder hardware verstaan we de computer en alles wat daarbij hoort, dus het beeldscherm, de harde schijf, het toetsenbord, enz. Vaak zitten al deze componenten in één behuizing, soms ook zijn ze er met een kabel (of draadloos) mee verbonden, zoals het geval is met een externe schijf, een printer of een beeldscherm. Zelfs als je je fototoestel via een kabel of draadloos verbindt met de computer, hoort deze bij de hardware.

Het hart van de computer wordt gevormd door een microprocessor. Dit is een chip die instructies in machinetaal kan uitvoeren. Alle programma's op je computer bestaan uit deze machinetaal. Naast de microprocessor bevat de computer ook een hoeveelheid intern geheugen. Dit wordt gebruikt om de programma's en gegevens op te slaan waarmee je werkt. Als je een programma start, wordt het vanaf de harde schijf in het geheugen geladen, waarna het wordt gestart. Ook gegevens die op de harde schijf staan worden zo nodig in het geheugen geladen om ze te kunnen bewerken. Het nadeel van dit intern geheugen is dat het "vluchtig" is. Als de stroom uitvalt, wordt het intern geheugen gewist. Dat is de reden dat je je werk kwijt bent als je computer plotseling uitvalt of een blauw scherm geeft. Vervolgens heeft de computer nog aansluitingen voor randapparatuur zoals toetsenbord, muis en beeldscherm.

Naast intern geheugen bestaat er ook extern geheugen. Het voornaamste is de harde schijf, waarop allerlei programma's en bestanden opgeslagen kunnen worden. Daarnaast bestaan er ook SSD-schijven, USB-sticks en DVD's die als extern geheugen gebruikt kunnen worden. Meestal zijn dit alleen bestanden zoals afbeeldingen en tekstbestanden, maar in principe geen programma's.

Onder software verstaan we alle programma's die je op de computer kunt gebruiken. De volgende hoofdgroepen worden onderscheiden:

  1. het BIOS
  2. het operating system
  3. systeemsoftware
  4. gebruikerssoftware

Het BIOS (Basic Input/Output System) is speciale software die zich op een chip in de computer bevindt. Deze software zorgt voor de koppeling tussen de overige software en de computer. Het BIOS zorgt bijvoorbeeld voor de aansturing van het beeldscherm, het toetsenbord en de harde schijf. Daarom wordt het BIOS speciaal geschreven voor een bepaald type en merk computer.

Het operating system (Nederlands: besturingssysteem of bedrijfssysteem) zorgt ervoor dat je met de computer kunt werken. Het biedt dus een soort "platform" waarop de gebruikerssoftware "draait". Ook biedt het mogelijkheden om bijvoorbeeld bestanden te beheren, randapparatuur aan te sluiten, enz. Het bekendste operating system is Windows, maar daarnaast kennen we o.a. Unix/Linux in diverse varianten, OS X voor Mac-computers en Android voor tablets en smartphones.

De systeemsoftware is een algemene benaming voor de software die je nodig hebt om je computer te kunnen gebruiken. Soms wordt het operating system ook tot de systeemsoftware gerekend. Maar je kunt ook denken aan programma's als Verkenner, Internet Explorer en Media Player.

Gebruikerssoftware is alle andere software die je koopt of gratis van internet haalt. Denk aan een tekstverwerker, een programma om foto's of muziek te bewerken, een tekenprogramma of een programma om DVD's af te spelen. Ook Visual Basic hoort bij de gebruikerssoftware, evenals de programma's die je er mee maakt.

Wat is programmeren?[bewerken]

Een programma is een werkinstructie voor een computer. Het beschrijft wat de computer moet doen. Je kunt een programma enigszins vergelijken met een recept uit een kookboek. Een recept omschrijft precies wat de kok (de computer) moet doen om tot het gewenste resultaat te komen.
Het bijzondere van een recept is dat dit bestaat uit twee delen: de lijst met ingrediënten en de werkwijze. In een programmeertaal kennen we in feite ook ingrediënten en een werkwijze. De ingrediënten noemen we hier gegevens of variabelen en de werkwijze het eigenlijke programma. Zo kunnen we in een programma schrijven: Neem de postcode en zoek hierbij de bijhorende straat op. Plaats het huisnummer achter de postcode en toon het resultaat op het scherm.

Door een aantal van deze instructies achter elkaar te plaatsen ontstaat in het ene geval een volledig recept en in het andere geval een compleet computerprogramma. Eigenlijk is programmeren niet zo moeilijk. Maar om goed te kunnen programmeren, en zeker onder Windows, komt er heel wat meer bij kijken.

De geschiedenis van het programmeren[bewerken]

Een programma bestaat dus uit instructies voor de computer. Maar wat de programmeur schrijft, is voor de computer eigenlijk niet leesbaar. Een computer kent alleen maar een beperkt aantal eenvoudige instructies, bijvoorbeeld om te rekenen of om twee getallen met elkaar te vergelijken. Die computerinstructies bestaan uit nullen en enen. Iedere computer heeft een apart onderdeel dat niets anders doet dan het uitvoeren van dergelijke instructies. Dit onderdeel heet CPU (Central Processing Unit ofwel Centrale Verwerkingseenheid). Maar niet alleen de instructies bestaan uit nullen en enen. Ook alle gegevens, of het nu getallen zijn, teksten of afbeeldingen, bestaan uit nullen en enen.
De allereerste computerprogramma's werden daarom ook geschreven als combinaties van nullen en enen. Vervolgens werd het programma met behulp van schakelaars ingevoerd in de computer: als de schakelaar omhoog stond, was het een 1, stond de schakelaar omlaag, dan was dat een 0. Als de schakelaars goed stonden, werd de waarde met een druk op de knop in het geheugen van de computer gezet. Daarna was de volgende instructie aan de beurt. Zoals je je kunt voorstellen was het programmeren van de eerste computers heel omslachtig en was de kans op fouten heel groot. Kijk maar eens hoe zo'n programma eruit kon zien:

1101 1100 1001 0010
0000 1111 1100 0011
1101 1110 0010 0111

Voor de computer is dit gesneden koek, maar voor de mens is dit gewoon een wirwar van nullen en enen. Omdat deze "programmeertaal" direct door de machine verwerkt kan worden, sprak men van machinetaal. Letterlijk een taal voor de machine, maar praktisch onbruikbaar voor de mens.

Daarom werd van deze machinetaal een versie bedacht in een voor de mens leesbare vorm, die vervolgens door een apart programma vertaald werd in machinetaal. De leesbare vorm noemde men assemblertaal en het vertaalprogramma heette assembler. In de assemblertaal wordt iedere instructie weergegeven door een woord of afkorting die voor de mens begrijpbaar is. Onderstaand assemblerprogramma is beter leesbaar voor de mens:

lda     5
ldb     8
add     a,b
st      a, som

Dit programma plaatst de waarde 5 in register a en de waarde 8 in register b. Vervolgens wordt de inhoud van register b opgeteld bij de inhoud van register a. Vervolgens wordt het resultaat opgeslagen in de variabele met de naam som.

De assembler vertaalt bovenstaande instructies in nullen en enen die het machinetaalprogramma vormen en dat de computer kan uitvoeren. Omdat het programma nu leesbaar is voor de mens, is de kans op fouten veel kleiner.

Maar deze assemblertaal is nog altijd omslachtig, omdat iedere instructie in machinetaal weergegeven wordt als één instructie in assemblertaal. Het is alsof je een kasteel bouwt van legoblokjes. Daarom zijn nieuwe programmeertalen ontwikkeld waarmee het programmeren een stuk gemakkelijk is en sneller gaat. Het bijzondere is dat in deze "hogere" programmeertalen één instructie vertaald wordt in meerdere machinetaal-instructies. Het geheel lijkt nu meer op een prefab-woning. Je hebt grote onderdelen die gemakkelijk en snel gemonteerd worden tot één geheel. Hierdoor worden programma's korter en zijn ze sneller te schrijven. Ook hoeft de programmeur zich in principe niet meer bezig te houden met de details van de computer zoals welke registers er zijn en hoe het beeldscherm aangestuurd moet worden.

In de eerste versie van Basic zou bovenstaande machinetaalprogramma er als volgt uit kunnen zien:

0100 LET som = 5 + 8

Zoals je ziet, is dit programma nu heel kort en leesbaar. De "0100" vooraan de regel is het regelnummer. Die regelnummers worden in moderne talen niet meer gebruikt.

Zo'n hogere programmeertaal wordt niet meer vertaald door een assembler, maar door een compiler. Maar het resultaat is hetzelfde: een programma in machinetaal dat rechtstreeks op de computer uitgevoerd kan worden.

In de loop van de tijd zijn honderden programmeertalen en duizenden varianten ontwikkeld. De voornaamste reden is vaak dat een bepaalde programmeertaal bedoeld is om bepaalde problemen op te lossen. Zo is de taal COBOL speciaal geschreven om administratieve problemen op te lossen. De nadruk ligt op het gemakkelijk werken met gegevens het nauwkeurig rekenen.
De taal C daarentegen is in eerste instantie ontwikkeld voor het schrijven van operating systems (besturingssystemen zoals DOS en Windows) en zogenaamde device drivers, kleine programma's om apparaten zoals een printer aan te sturen. Daardoor kan met C de computer heel nauwkeurig bestuurd worden. Het grote nadeel is dat het verwerken van gegevens een stuk moeilijker is dan bijvoorbeeld in COBOL. Dat blijkt bijvoorbeeld uit het gebruik van pointers in C, hetgeen het programmeren duidelijk ingewikkelder maakt (andere talen verbergen de pointers voor de programmeur) en het feit dat C (en afgeleide talen) de index van arrays laat beginnen bij 0 i.p.v. zoals toen gebruikelijk bij 1.
Zo heeft iedere taal zijn speciaal doel met bijbehorende voor- en nadelen. Een computertaal die in alle omstandigheden even geschikt is, bestaat daarom ook niet. Daarom heeft men geprobeerd om "general purpose"-talen te ontwikkelen: programmeertalen waarmee een breed scala aan problemen opgelost kan worden. Ook BASIC is zo'n taal.

Kenmerken van een programmeertaal[bewerken]

Een computertaal, of dit nu een assemblertaal is of een hogere programmeertaal, bestaat uit een aantal opdrachten, ook wel instructies genoemd. Iedere instructie heeft een bepaald doel, bijvoorbeeld getallen optellen, of een beslissing nemen. Maar veel instructies zijn in de meeste computertalen (ongeveer) hetzelfde. Zo kennen alle talen instructies om te rekenen en met teksten te werken. Maar toch verschillen talen van elkaar omdat ze een andere syntax hebben. De syntax geeft aan welke sleutelwoorden een taal heeft en hoe ze gecombineerd mogen worden. De syntax is te vergelijken met de woordenschat en de grammatica van een menselijke taal.

De sleutelwoorden (Engels: keywords) zijn elementen van een programmeertaal die een vastgestelde betekenis hebben. De meeste sleutelwoorden zijn opdrachten die uitgevoerd moeten worden. Andere sleutelwoorden geven bijvoorbeeld aan of een variabele een getal of een tekst is en of een getal wel of geen cijfers achter de komma heeft.

Vaak worden programmeeromgevingen geleverd met verschillende bibliotheken. Met een bibliotheek wordt hier een verzameling bedoeld van stukjes programma die de programmeur kan gebruiken om bepaalde taken uit te voeren. Vooral voor het werken met vensters en de muis (de interactie met de gebruiker) zijn veel van dergelijke stukjes programma beschikbaar.

Algoritmen[bewerken]

Voordat we een programma schrijven, moeten we eerst bekijken wat het programma moet doen. We moeten met andere woorden een beschrijving opstellen hoe het programma moet werken. Hiervoor hebben we een algoritme nodig: een reeks instructies om vanaf een bepaald beginpunt een bepaald doel te bereiken. Maar een algoritme heeft niet alleen betrekking op programmeren. Iedere reeks instructies om een bepaald doel te bereiken, vormen samen een algoritme. Denk bijvoorbeeld aan een recept. Daarin staat wat je nodig hebt om een bepaald gerecht te maken en welke stappen je moet uitvoeren om tot het gewenste resultaat te komen. Een ander algoritme is bijvoorbeeld de reeks instructies bij een kaartautomaat op een station. Ook daar moet je bepaalde stappen doorlopen om tot het gewenste resultaat (een treinkaartje naar je bestemming) te komen.

Als voorbeeld een algoritme om het gemiddelde van een aantal getallen te bepalen:

  • tel alle getallen bij elkaar op
  • deel het totaal door het aantal getallen

Voor jou zijn deze stappen duidelijk, maar voor een computer niet. Die wil gedetailleerdere instructies, bijvoorbeeld:

  1. maak totaal gelijk aan nul
  2. maak teller gelijk aan nul
  3. lees een getal in
  4. tel het getal op bij totaal
  5. tel 1 op bij teller
  6. als nog niet alle stappen zijn verwerkt, ga naar stap 3
  7. deel totaal door teller
  8. toon totaal aan de gebruiker

Ter verduidelijking: in stap 6 wordt teruggesprongen naar stap 3. Deze constructie (de oude Basic gebruikte hiervoor GoTo) getuigt van een slechte programmeerstijl en is in de meeste programmeertalen zelfs niet mogelijk. Daarvoor in de plaats zijn andere constructies gekomen, zoals in onderstaand voorbeeld.

Zoals je ziet, moet een algoritme voor een computer eenduidig zijn en heel gedetailleerd. En vervolgens kunnen we deze instructies, het algoritme, omzetten in een programma. De grbuikte programmeertaal bepaalt welke instructies gebruikt kunnen worden om het algoritme uit te voeren. Onderstaand voorbeeld is geschreven in een fictieve taal, gebaseerd (zoals bijna alle programmeertalen) op het Engels. Voor alle duidelijkheid zijn de regels genummerd, zodat ernaar verwezen kan worden in de toelichting. Deze regels zijn dus geen onderdeel van het programma.

1	Begin
2	  totaal = 0
3	  teller = 0
4         gemiddelde = 0
5	  Input getal
6	  While getal > 0
7	    totaal = totaal + getal
8	    teller = teller + 1
9	    Input getal
10	  End While
11	  if teller > 0 then gemiddelde = totaal / teller
12	  Output gemiddelde
13	End

De regels 1 en 13 geven respectievelijk het begin en het einde van het programma aan. In de regels 2 t/m 4 worden de variabelen totaal,teller en gemiddelde aangemaakt en krijgen deze de waarde 0. In regel 5 wordt een getal opgehaald (hoe wordt hier buiten beschouwing gelaten, dit is afhankelijk van de programmeertaal en of het getal uit een bestand komt of door de gebruiker wordt ingetikt). De regels 6 t/m 10 vormen een While-lus: zolang het gelezen getal groter is dan 0, wordt deze lus doorlopen. Een getal gelijk aan of kleiner dan 0 geeft aan dat het einde van de reeks getallen bereikt is. In deze lus wordt getal opgeteld bij totaal (regel 7), de teller verhoogd met 1 (regel 8) en een nieuw getal gelezen (regel 9). Regel 11 berekent het gemiddelde als er minimaal een getal is gelezen. Deze conditie is nodig omdat anders een runtime-error kan ontstaan (delen door nul). Regel 12 toont het gemiddelde aan de gebruiker.

Zoals je ziet springen de regels tussen Begin en End in met twee spaties en tussen While en End While nog eens met twee spaties extra. Dit wordt meestal gedaan om aan te geven welke opdrachten bij elkaar horen. Op deze manier is de structuur van het programma duidelijk zichtbaar.
Ook zie je dat bepaalde woorden beginnen met een hoofdletter. Dit zijn de sleutelwoorden van de programmeertaal, waardoor ze meteen opvallen. Veel programmeertalen kennen het gebruik van sleutelwoorden die beginnen met een hoofdletter (ook Visual Basic, hoewel Visual Basic geen onderscheid maakt tussen hoofdletters en kleine letters; dat verschil is er alleen voor de programmeur).

Misschien vraag je je af waarom zowel in regel 5 als regel 9 een getal gelezen wordt. Dat is toch dubbel? Nee, toch niet. Stel dat we een lege rij getallen hebben (dus het eerste getal is nul). Die situatie onderkennen we alleen als we een getal lezen, testen p einde reeks en daar weer het volgende getal lezen. Een goede programmeur houdt altijd rekening met dit soort uitzonderingen.

Soorten programmeertalen[bewerken]

Er zijn de volgende soorten programmeertalen, meestal generaties genoemd:

  • machinetalen (1e generatie)
  • assembleertalen of lagere programmeertalen (2e generatie)
  • hogere programmeertalen (3e generatie en hoger)

Machinetalen[bewerken]

Een taal is een middel om te communiceren. Dat geldt ook voor computers. Er is eigenlijk maar één taal waarmee we met een computer kunnen communiceren: de machinetaal (of: computertaal). Een programma bestaat uit instructies, die weer bestaan uit een reeks nullen en enen, meestal een veelvoud van acht. Dit komt omdat een computer slechts twee toestanden kent en daardoor ook twee cijfers: 0 en 1. Alle gegevens, maar ook alle programma's, bestaan dus uit nullen en enen.

Wij mensen rekenen in een tientallig stelsel, omdat we tien verschillende cijfers kennen. Computers rekenen in het tweetallig stelsel, ook wel binair stelsel genoemd, omdat een computer maar twee cijfers kent. Een cijfer in het tweetallig stelsel wordt bit genoemd. Een groep van acht bits heet een byte. Bij sommige computerinstructies is deze kennis over bits en bytes nodig.

Een instructie in machinetaal kan er als volgt uitzien:

0011100100111100

De machinetaal is afhankelijk van het soort processor in de computer. Iedere processorfamilie heeft zijn eigen "taal". Dat is de reden dat een programma dat is geschreven voor een PC niet werkt op bijvoorbeeld een supercomputer of de meestal tablets. Gelukkig hebben de meeste PC's dezelfde soort processor (van Intel of AMD), die dezelfde machinetaal "spreken".

Omdat mensen niet gewend zijn aan machinetaal met al die nullen en enen, is men voor de notatie snel overgestapt op het hexadecimale stelsel. Dit stelsel kent 16 cijfers: 0 t/m 9 (0000 t/m 1001) en A t/m F (1010 t/m 1111). Een hexadecimaal cijfer komt overeen met vier binaire cijfers, en een byte bestaat dus uit twee hexadecimale cijfers. De binaire instructie hierboven wordt als volgt weergegeven in het hexadecimale stelsel:

393C

Deze notatie is voor mensen duidelijker en zorgt voor minder fouten.

Oude computers (uit de jaren 60 en 70 van de vorige eeuw) werden in machinetaal geprogrammeerd op twee manieren. Bij de binaire methode bestond de invoer uit een reeks schakelaars (een veelvoud van acht) die ieder de waarde 0 (uit) of 1 (aan) vertegenwoordigden. De programmeur zette de schakelaars in de juiste stand, waarna met een druk op de knop de waarden werden opgeslagen in het geheugen. Later ontstond (vooral bij hobby-computers) de hexadecimale invoer: hierbij bevinden zich op de kast van de computer zestien toetsen (0 t/m 9 en A t/m F) en een paar functies. Om een programma in te voeren moesten er eerst hexadecimale tekens (gelijk aan één byte) worden ingevoerd, waarna door een druk op de functietoets de waarde in het geheugen werd opgeslagen. Daarna kon de volgende byte worden ingevoerd. Erg omslachtig en een tikfout was snel gemaakt. Dat is de reden waarom de tweede generatie programmeertalen is ontworpen.

Assembleertalen[bewerken]

De assembleertaal bracht de machinetaal meer naar de mens. Hierbij wordt iedere machinetaal-instructie geschreven in een symbolische taal, die voor mensen gemakkelijk te begrijpen is. In deze symbolische taal wordt iedere machinetaal-instructie voorgesteld door een leesbare instructie, meestal aangevuld met zogenaamde parameters, die aangeven waarop de instructie betrekking heeft. Iedere machinetaal had zijn eigen assembleertaal, omdat er een een-op-een-verhouding bestaat tussen machinetaal en assembleertaal. Mogelijke instructies zijn:

CLR   4
ST    4, teller
LD    5, teller
INC   5
ST    5, teller

De eerste instructie zet register 4 op nul (CLR = clear). De tweede instructie bewaart de inhoud van register 4 in de geheugenplaats met de naam teller (ST = store). De derde instructie laadt (LD = load) de inhoud van teller in register 5. De vierde instructie vermeerdert de inhoud van register 5 met 1 (INC = increment). De vijfde instructie slaat de inhoud van register 5 op in geheugenplaats teller.

Deze instructies zijn gemakkelijk te lezen voor de mens, maar de computer kan er niets mee. Daarom moet er een apart programma zijn, de assembler, die de assembleertaal omzet in machinetaal. En daarna kan het programma op de computer worden uitgevoerd.

Hoge programmeertalen[bewerken]

Werken met assembleertalen is nog altijd heel omslachtig. Daarom zijn er hogere programmeertalen ontwikkeld. Hierbij komt één instructie in de hogere programmeertaal overeen met meerdere instructies in machinetaal. Stel, je wilt twee getallen in de variabelen getal1 en getal2 bij elkaar optellen en het resultaat opslaan in de variabele totaal. In assembleertaal ziet dit er als volgt uit:

LD   4, getal1
LD   5, getal2
ADD  4, 5
ST   4, totaal

In een hogere programmeertaal kan dit als volgt geprogrammeerd worden:

totaal = getal1 + getal2

Een hogere programmeertaal kan dus in één instructie hetzelfde doen als meerdere machinetaalinstructies.

Een van de eerste programmeertalen, ontwikkeld in de jaren 60, is Basic, waar Visual Basic van is afgeleid.

Vaak worden meerdere generaties onderscheiden (3e, 4e en 5e generatie), maar men is er niet helemaal over eens waar de grenzen van deze generaties liggen. Voor het begrip van programmeertalen is dit onderscheid in generaties meestal niet nodig.

Compilers[bewerken]

Programma's in een hogere programmeertaal moeten vertaald worden naar machinetaal. Het programma dat hiervoor gebruikt wordt heet een compiler. Zo'n programma vertaalt het geschreven programma (het bronprogramma) in machinetaal (het doelprogramma). Tegenwoordig zijn compilers meestal onderdeel van een geïntegreerde ontwikkelomgeving (IDE = integrated development environment), waarmee niet alleen het programma wordt geschreven, maar ook de gebruikersinterface wordt ontworpen (de schermen met knoppen, vakken en andere elementen die de gebruiker ziet als hij met het programma werkt).

Vaak worden programma's niet gecompileerd naar machinetaal, maar naar een tussentaal. Dit gebeurt o.a. met Java-programma's en programma's voor het .NET-platform. Als het programma wordt uitgevoerd, wordt het door een speciale compiler, de Just in time compiler (JIT) gecompileerd naar machinetaal. Dit is natuurlijk ingewikkelder dan een rechtstreekse compileren naar machinetaal, maar door de tussentaal is het mogelijk om deze op verschillende soorten processors uit te voeren. Microsoft is daar niet zo'n fan van, maar hetzelfde Java-programma draait op zowel een PC als een MAC als een grote bedrijfscomputer. Als er maar een JIT-compiler voor de betreffende processor bestaat.

De fasen in het programmeren[bewerken]

Veel mensen menen dat programmeren bestaat uit het inkloppen van instructies op de computer en dat daarmee de kous af is. Jammer genoeg werkt het zo niet. Hooguit voor heel kleine programma's (stel maximaal 50 regels), maar grotere programma's vergen een gedegen aanpak. Om tot zo'n gedegen aanpak te komen, is het hele proces onderverdeeld in een aantal stappen:

  1. De probleemdefinitie: In deze stap wordt het probleem beschreven. Deze beschrijving is heel algemeen. Je omschrijft het probleem en welke gegevens nodig zijn om het probleem op te lossen. Probeer de volgende vragen te beantwoorden: Wat moet het programma doen? Welke gegevens moet het programma leveren? Welke gegevens heeft het programma hiervoor nodig?
  2. De probleemanalyse: In deze stap wordt een oplossing voor het probleem gezocht. Omdat er vaak meerdere oplossingen zijn, moet ook de juiste oplossing worden gekozen. Tijdens de probleemanalyse wordt (in ruwe stappen) aangegeven hoe het programma moet werken. Zo nodig wordt het probleem verdeeld in meerdere kleine problemen, die gemakkelijker te analyseren zijn. Het resultaat van de probleemanalyse bestaat vaak uit een beschrijving van de oplossing van het probleem, vaak aangevuld met diagrammen en schema's die de programmeur moeten helpen bij zijn werk.
  3. Het programmeren: pas in deze stap wordt echt geprogrammeerd. De documenten die gemaakt zijn tijdens de probleemanalyse worden nu gebruikt om het eigenlijke programma te schrijven.
  4. Het testen: Fouten maken is menselijk. Bijna ieder programma, vooral de wat grotere, bevatten fouten. Tijdens het testen wordt gekeken of het programma in alle situaties goed werkt. De eerste fase bestaat erin om te kijken of het programma doet wat het moet doen. Een tweede, heel belangrijke, fase is kijken wat het programma doet als foutieve gegevens worden ingevoerd. Het programma moet hier rekening mee houden. Sommige fouten zijn heel lastig te vinden, bijvoorbeeld een deling door nul. Vaak wordt gesteld dat je voor het testen evenveel tijd moet gebruiken als voor het programmeren. Dit geeft al aan hoe belangrijk het testen is.
  5. Het documenteren: Als je een programma schrijft, weet je precies wat je doet en hoe het programma werkt. Maar als je na verloop van tijd het programma wilt aanpassen, kan het zijn dat je dit niet meer precies weet. Daarom dient het programma gedocumenteerd te worden. Vaak nemen programmeurs commentaar op in het programma waarin staat hoe en waarom iets zo geprogrammeerd is. Bij de documentatie hoort ook een gebruikershandleiding. Als je een programma voor eigen gebruik schrijft, kan deze handleiding beknopt zijn, maar als je bijvoorbeeld het programma via internet verspreidt, dient de handleiding uitgebreid te zijn en samen met het programma verspreid te worden.
Informatie afkomstig van http://nl.wikibooks.org Wikibooks NL.
Wikibooks NL is onderdeel van de wikimediafoundation.