Inhoud
- Wat is computationeel denken?
- Computationeel denken versus programmeren
- De 4 hoekstenen van het computationeel denken
- Ontleding/Decomposition in detail
- Patroon herkenning/Pattern Recognition in detail
- Abstractie/abstraction in detail
- Algoritmen/algorithms in detail
- De oplossing evalueren
- Hoe Google computationeel denken in de praktijk toepast
Bron: BBC .
Wat is computationeel denken?
Computational Thinking is the thought processes involved in formulating problems and their solutions so that the solutions are represented in a form that can be effectively carried out by an information-processing agent. (Jeanette Wing, 2010)
Computers, en bij uitbreiding “an information-processing agent” zoals een tablet, smartphone,…, kunnen gebruikt worden om problemen op te lossen. Maar, voor het probleem kan worden opgelost moet het probleem zelf, en de mogelijke oplossingen, begrepen zijn.
Een computer gebruiken om een probleem op te lossen gebeurt in 2 stappen:
- U denkt na over het probleem, u probeert het probleem te begrijpen en bedenkt stappen om het op te lossen.
- U schrijft een computerprogramma zodat de computer het probleem kan oplossen op basis van de oplossing aangereikt na puntje 1.
Computationeel denken helpt u een complex probleem te begrijpen en mogelijke oplossingen te bedenken. Deze oplossingen worden dan gepresenteerd op een manier dat het door de computer, de mens, of beiden begrepen en uitgevoerd kan worden.
Computationeel denken valt dus onder punt 1 (U denkt na over het probleem, u probeert het probleem te begrijpen en bedenkt stappen om het op te lossen.).
Computational thinking allows us to take a complex problem, understand what the problem is and develop possible solutions. We can then present these solutions in a way that a computer, a human, or both, can understand.
Computationeel denken versus programmeren
Computationeel denken is niet gelijk aan programmeren, het is ook niet gelijk aan denken als een computer.
- Computationeel denken helpt u om te bepalen wat de computer zal moeten doen.
- Een programma vertelt de computer wat het moet doen en hoe het moet gedaan worden.
Computational thinking enables you to work out exactly what to tell the computer to do.
De 4 hoekstenen van het computationeel denken
De 4 hoekstenen van het compuationeel denken zijn:
- Ontleding (decomposition): een complex probleem opdelen in kleinere, meer hanteerbare (deel)problemen.
- Patroonherkenning (pattern recognition): zoeken naar patronen, overeenkomsten tussen en binnen de (deel)problemen.
- Abstractie (abstraction): focussen op wat belangrijk is en bijzaken negeren.
- Algoritme opstellen (algorithms): ontwerp een stap voor stap oplossing voor het (deel)probleem. De regels/stappen, die moeten gevolgd worden om het (deel)probleem op te lossen.
Deze 4 hoekstenen zijn alle 4 belangrijk. als u 1 van de hoekstenen weglaat, of niet voldoende uitwerkt, zou wel eens heel het “gebouw” kunnen instorten.
Een complex probleem is een probleem waarvan u, op het eerste zicht, niet weet hoe u het eenvoudig kunt oplossen. Computationeel denken zal een complex probleem opdelen in een reeks van kleine, meer handelbare (deel)problemen (decomposition). Elk van deze kleinere (deel)problemen kunnen dan individueel bekeken worden. Er wordt gekeken naar gelijkenissen tussen de (deel)problemen en hoe gelijkaardige problemen in het verleden opgelost zijn (pattern recognition). Er wordt gefocust op de belangrijkste elementen, terwijl irrelevante details genegeerd worden (abstraction). Tenslotte worden eenvoudige stappen (of regels) opgesteld om elk van deze kleinere (deel)problemen op te lossen (algorithms).
Indien u het probleem wilt oplossen met de computer, zullen de eenvoudige stappen (of regels), het algoritme dus, gevolgd worden om het programma te programmeren.
Bijvoorbeeld, u hebt een probleem, u moet “Een communiefeest geven voor uw zoon/dochter”.
Dit is een complex probleem! Laten we dit probleem eens aanpakken vanuit de 4 hoekstenen van computationeel denken.
Decomposition
U begint met het probleem op te delen in kleinere (deel)problemen. Deze zouden kunnen zijn:
- Wanneer houdt u het feest?
- Waar houdt u het feest?
- Wie nodigt u uit?
- Hoe nodigt u de mensen uit?
- Wat staat er op het menu?
- Voorziet u animatie en zo ja, welke?
- Welke kleren dragen u en uw zoon/dochter?
- Wat is uw budget en hoe financiert u het feest?
Pattern recognition
U hebt misschien al eens een ander feestje gegeven. U herkent bepaalde patronen in het organiseren van feestjes.
- Misschien kunt u dezelfde locatie gebruiken? En zo het probleem van de locatie oplossen!
- Misschien kunt u dezelfde mensen uitnodigen? En zo het probleem “Wie nodigt u uit?” oplossen!
- Misschien kunt u dezelfde clown vragen voor de animatie? En zo het probleem van de animatie oplossen!
- Een uitnodiging ontwerpen heeft gelijkenissen met het ontwerpen van het menu. U kunt misschien dezelfde software gebruiken, dezelfde afbeeldingen hergebruiken?
U zal bepaalde patronen herkennen met het vorige feestje omdat ieder feestje nu eenmaal volgens een aantal vaste patronen verloopt. Zo kunt u de oplossingen, de algoritmen, die u tijdens het vorige feestje gebruikt hebt opnieuw, eventueel mits kleine wijzigingen, hergebruiken.
Abstraction
U focust u op de belangrijke elementen en niet op de details.
- U gaat uiteraard bepalen waar het feest doorgaat, en misschien een map van de locatie voorzien, maar u gaat u niet bezig houden met de route voor elk van uw genodigden uit te stippelen.
- Vermits u een kok vraagt om het eten te maken gaat u zich niet bezighouden met de benodigde ingrediënten, enkel met de samenstelling van het menu.
- U besluit misschien dat u nieuwe schoenen nodig hebt maar u ligt nog niet meteen wakker van de kleur (sommige vrouwen zullen dit misschien niet meteen als een abstractie zien).
Algorithms
U gaat de oplossing voor elk van de problemen stap voor stap uitwerken.
Voor het probleem “Waar houdt u het feest?” bepaalt u bv. volgende stappen:
- U gaat, via internet, op zoek naar een zaal die vrij is op de gekozen datum.
- U maakt een afspraak om de zaal te bekijken.
- U boekt eventueel de zaal of u herneemt uw zoektocht naar een andere zaal.
- Indien u geen geschikte zaal vindt kiest u eventueel een andere datum, waarop een geschikte zaal vrij is, of u houdt u het feest bij u thuis.
Vindt u dit allemaal vrij logisch? Dan hebt u wellicht al vaker, onbewust, computationeel denken toegepast om problemen op te lossen.
Ontleding/Decomposition in detail
Ontleding (decomposition) houdt in dat u een complex probleem ontleedt/opdeelt in een aantal kleinere (deel)problemen die elk op zich gemakkelijker te begrijpen en op te lossen zijn.
Decomposition is one of the four cornerstones of Computer Science. It involves breaking down a complex problem or system into smaller parts that are more manageable and easier to understand. The smaller parts can then be examined and solved, or designed individually, as they are simpler to work with.
Waarom is decomposition belangrijk?
Als een complex probleem niet ontleed wordt is het moeilijker op te lossen omdat het simpelweg moeilijker is een complex probleem in zijn geheel op te lossen dan het eerst te ontleden en nadien de verschillende (deel)problemen ieder op zich op te lossen.
Een kleiner probleem zal al snel meer details onthullen. Deze details zullen eenvoudiger te begrijpen zijn en zo bijdragen tot de algehele oplossing.
Bijvoorbeeld, u wilt weten “Hoe een complex systeem als een hybride elektrische auto werkt”.
Als u de auto in zijn geheel bekijkt en bestudeert zal u wellicht niet snel achterhalen hoe deze werkt.
Als u echter de motorkap opent en u bekijkt de motor op zich dan hebt u toch al meteen meer overzicht (inzicht) in de verschillende onderdelen en hoe ze kunnen bijdragen tot het werkend geheel. Als u dan nog de verschillende onderdelen meer in detail gaat bestuderen zal u veel gemakkelijker de werking van een (hybride elektrische) auto kunnen achterhalen dan wanneer u gewoon blijft staren naar de auto in zijn geheel.
Pas op, verlies u niet in de details, maar dit is dan weer een andere hoeksteen (abstraction).
Bijvoorbeeld, u hebt een probleem, u wilt “een misdaad oplossen”.
U speelt even voor detective en wilt een (kleine, onschuldige) misdaad oplossen. U zal u wellicht niet beperken tot die ene vraag “Wie is de dader?”. Ook al is dit wat u uiteindelijk wilt weten, toch zal u deze ene, complexe, vraag opdelen in een reeks meer gedetailleerde vragen die elk op zich gemakkelijker te beantwoorden zijn en die, indien ze allemaal correct beantwoord zijn, het antwoord zullen opleveren voor de hoofdvraag “Wie is de dader?”.
Een goede detective zal het complexe probleem “Wie is de dader?” proberen op te lossen door oplossingen te vinden voor verschillende kleinere problemen zoals:
- Wat is de misdaad?
- Wanneer is de misdaad gepleegd?
- Waar is de misdaad gepleegd?
- Waren er getuigen?
- Is er mogelijk bewijsmateriaal achtergelaten?
- Zijn er, recent, gelijkaardige misdaden begaan (patroon herkenning)?
Het oplossen van elk van deze (deel)problemen, op zich eenvoudig(er) op te lossen, kan/zal leiden tot de oplossing van het eigenlijke probleem “Wie is de dader?”.
Nu het probleem ontleed is in kleinere deelproblemen kunt u verder gaan naar de volgende hoeksteen: Patroon herkenning.
Patroonherkenning/Pattern Recognition in detail
Patroonherkenning houdt in dat u op zoek gaat naar gelijkenissen, gemeenschappelijke kenmerken tussen de kleinere, ontlede (deel)probleem die kunnen helpen om het grotere complexe probleem efficiënter op te lossen.
Pattern recognition is one of the four cornerstones of Computer Science. It involves finding the similarities or patterns among small, decomposed problems that can help us solve more complex problems more efficiently.
Wat zijn patronen?
Bijvoorbeeld, u hebt een probleem, u wilt “Een kat tekenen”.
Na ontleding (decomposition) zal één van de op te lossen problemen zijn:
- Hoe ziet een kat eruit?
U moet dus weten hoe een kat eruit ziet en u besluit katten te observeren (of, moderne mens die we zijn, googlen op “kat” en bekijken de foto’s).
Als u de eerste kat bekijkt, ziet u nog geen patroon. U ziet wel 4 poten, een staart, een vacht, 2 ogen,… U merkt op dat ze graag muizen eet en een raar geluid maakt. Allemaal leuk om vast te stellen maar nog geen patroon.
Als u nu een tweede kat bekijkt dan ziet u opnieuw 4 poten, een staart (misschien wat langer/korter dan de staart van de eerste kat), een vacht (misschien met een andere kleur dan de vacht van de eerste kat), 2 ogen (misschien een andere kleur dan de ogen van de eerste kat). Ook deze kat eet graag muizen en maakt een gelijkaardig raar geluid.
Als u nu een derde kat bekijkt dan ziet u opnieuw 4 poten, een staart, een vacht, 2 ogen. Ook deze kat eet graag muizen en maakt een gelijkaardig raar geluid. Dient er zich een patroon aan, gelijkenissen, gemeenschappelijke kenmerken? U hebt zo’n vermoeden.
U bekijkt nog een aantal katten en u herkent telkens dezelfde kenmerken, katten hebben:
- 4 poten
- een staart (zij het variërend in lengte en dikte)
- een vacht (zij het variërend in kleur)
- 2 ogen (zij het variërend in kleur)
- Katten eten graag muizen
- Ze maken een gelijkaardig raar geluid dat klinkt als “miauw”
Nu u weet dat een kat 4 poten, een staart, een vacht en 2 ogen heeft, kunt u beginnen met een kat te tekenen (dat ze miauwt draagt weinig bij tot het tekenen van de kat, het is een detail waar u abstractie kunt van nemen (zie de hoeksteen Abstraction)).
In computationeel denken worden deze terugkerende kenmerken een patroon genoemd.
Eens u weet hoe u één kat kunt tekenen, kunt u ook andere katten tekenen door simpelweg hetzelfde patroon te volgen. Het enige dat zal veranderen zijn de specificaties (de waarden van de kenmerken/eigenschappen).
- De ene kat heeft groene ogen, een lange staart en een zwarte vacht.
- Een andere kat heeft gele ogen, een korte staart en een gestreepte vacht.
Voor de eerste kat is groen de waarde die is toegekend aan de eigenschap/kenmerk Ogen, lang de waarde die is toegekend aan de eigenschap/kenmerk Staart en zwart de waarde die is toegekend aan de eigenschap/kenmerk Vacht.
Waarom is het zoeken naar patronen belangrijk?
Patronen vinden is enorm belangrijk als u een probleem wilt oplossen. Problemen worden immers gemakkelijker opgelost als ze een herkenbaar patroon delen omdat dan dezelfde oplossing kan (her)gebruikt worden.
Hoe meer patronen u herkent, hoe gemakkelijker en vlugger u een probleem kunt oplossen.
Finding patterns is extremely important. Patterns make our task simpler. Problems are easier to solve when they share patterns, because we can use the same problem-solving solution wherever the pattern exists.
The more patterns we can find, the easier and quicker our overall task of problem solving will be.
Terug naar onze katten.
Eens u het patroon ontdekt hebt voor het tekenen van katten (u weet wel, dat ze 4 poten hebben, de ogen, een vacht, een staart,…). Kunt u dit patroon opnieuw gebruiken iedere keer u een kat dient te tekenen. U hoeft u dus niet iedere keer opnieuw af te vragen hoe u die kat moeten tekenen, doordat u het patroon ontdekt heeft weet u reeds hoe u het probleem “Een kat tekenen” moet oplossen.
U zou het zelfs kunnen automatiseren door een stempel, een template, te maken die uw katten snel en efficiënt helpt te tekenen!
Stel even dat u niet achter een patroon had gezocht. Tja, dan zou u iedere keer u een kat moet tekenen u opnieuw moeten afvragen hoe een kat eruit ziet. Of erger, stel dat u geen patroon ontdekt zou hebben, dat u niet zou ontdekt hebben dat katten 4 poten, 2 ogen, een vacht en een staart hebben. Hoe zou uw kat er dan uitzien? U zou het probleem “Een kat tekenen” wellicht niet correct opgelost hebben.
Patronen zoeken tussen verschillende (deel)problemen
Het zoeken naar patronen is belangrijk om tot een snellere en efficiëntere oplossing te komen. Het is dus ook belangrijk om naar patronen te zoeken buiten het huidige probleem en op zoek te gaan naar gelijkenissen met andere problemen.
Bijvoorbeeld, u hebt een probleem, u wilt “Een hond tekenen”.
Maar, u hebt het probleem “Een kat tekenen” reeds opgelost. U zal wellicht snel opmerken dat er gelijkenissen zijn tussen beide problemen en dat u technieken/oplossingen die u gevonden hebt voor het tekenen van een kat kunt hergebruiken voor het tekenen van een hond. U zal opnieuw 4 poten, 2 ogen, een vacht en een staart moeten tekenen. Alleen zullen de specificaties, de waarden die worden toegekend aan de eigenschappen verschillen.
U zou verkeerdelijk tot de conclusie kunnen komen dat een kat en een hond gelijk zijn. Nu, niet echt, een hond miauwt niet en eet geen muizen maar zelfs als u een hond tekent zal u deze toch anders moeten tekenen dan een kat. U zal dus nog verder op zoek moeten naar andere patronen/kenmerken die een kat tot kat maken en een hond tot een hond.
De stempel die u gebruikt hebt voor de kat zal u niet kunnen hergebruiken voor de hond, maar de ervaring die u hebt opgedaan om de stempel van de kat te maken zal u helpen sneller en efficiënter een stempel voor een hond te maken.
Bijvoorbeeld, u hebt 2 problemen, “Een appeltaart bakken” en “Een chocoladetaart bakken”.
Als u eerst ontleding (decomposition) toepast op het probleem “Een appeltaart bakken” dan zal blijken dat u oplossingen moet vinden voor de problemen (of antwoorden op de vragen):
- Welke taart wilt u bakken?
- Welke ingrediënten, en hoeveel, hebt u nodig?
- Wanneer moeten de ingrediënten worden toegevoegd?
- Voor hoeveel personen moet de taart zijn?
- Hoe lang moet de taart in de oven staan?
- Op hoeveel graden moet de oven worden voorverwarmd?
- Welk “gereedschap” gebruikt u om de taart te maken?
Eens u weet hoe u een appeltaart moet bakken is het niet zo moeilijk om een ander type taart te bakken omdat “een taart bakken” volgens eenzelfde patroon verloopt ongeacht het type taart dat u wenst te bakken:
- De oven moet voorverwarmd worden op een aantal graden.
- Iedere taart bevat ingrediënten die in een juiste hoeveelheid gemengd moeten worden.
- Iedere taart moet een bepaalde tijd in de oven.
Eens u dit patroon bepaald hebt kunt u aan gemeenschappelijk oplossingen werken voor de problemen.
Once we have the patterns identified, we can work on common solutions between the problems.
De ontlede (deel)problemen kunnen eveneens patronen bevatten. Zo hebt u het (deel)probleem “Welke ingrediënten, en hoeveel, hebt u nodig?”.
Ook hier herkent u een patroon, namelijk dat ieder ingrediënt een:
- Naam (identificatie)
- Hoeveelheid
nodig heeft.
Zodra u weet hoe u elk ingrediënt en de hoeveelheid ervan kunt identificeren, kunt u dat patroon toepassen op alle ingrediënten. Het enige dat verandert zijn de waarden voor de eigenschappen/kenmerken Naam en Hoeveelheid (zoals de kleur van de Ogen, de kleur van de Vacht, en de lengte van de Staart de waarden waren die u moest meegeven aan de eigenschappen/kenmerken van de kat).
In onderstaande video legt singer/songwriter Aloe Blacc uit hoe patroonherkenning aan de basis ligt van digitale compressie van afbeeldingen en audio.
Abstractie/abstraction in detail
Abstractie houdt in dat eigenschappen/kenmerken (characteristics) binnen de ontdekte patronen die niet van belang zijn gefilterd, genegeerd worden, zodat de focus komt te liggen op wat belangrijk is.
Abstractie houdt eveneens in dat specifieke details gefilterd worden zodat een representatie, een model (een “idee”) kan gecreëerd worden van het probleem.
Abstraction is one of the four cornerstones of Computer Science. It involves filtering out – essentially, ignoring – the characteristics that we don’t need in order to concentrate on those that we do.
Abstraction is the process of filtering out – ignoring – the characteristics of patterns that we don’t need in order to concentrate on those that we do. It is also the filtering out of specific details. From this we create a representation (idea) of what we are trying to solve.
Wat zijn nu de specifieke details die moeten gefilterd worden?
Terug naar het probleem “Een kat tekenen”!
Uit patroonherkenning bleek dat katten een aantal algemene eigenschappen/kenmerken, die in computationeel denken patronen genoemd worden, hebben:
katten hebben:
- 4 poten
- een staart
- een vacht
- 2 ogen
- Katten eten graag muizen
- Ze maken een gelijkaardig raar geluid dat klinkt als “miauw”
Specifieke katten hebben specifieke eigenschappen/kenmerken:
- Er zijn katten met een zwarte vacht, een lange staart en blauwe ogen.
- Er zijn katten met een roze vacht, een korte staart en groene ogen.
De specifieke waarden die de algemene eigenschappen kunnen hebben worden specificaties genoemd.
Abstractie gebeurt op 2 “niveau’s”.
- Er wordt abstractie genomen van datgene dat niet relevant is voor de oplossing van het probleem.
- Er wordt abstractie genomen van specifieke details om zo tot een (basis)model te komen.
Om een kat te tekenen:
- moet u weten dat een kat 4 poten heeft, 2 ogen, een staart en een vacht. Deze eigenschappen zijn relevant voor het tekenen van een kat. Dat de kat miauwt en graag muizen is voor het teken van een kat niet relevant. U kunt dus abstractie nemen van het feit dat een kat miauwt en muizen eet. Voor het tekenen van een kat hebt u dit niet nodig, het interesseert u niet, u filtert het uit.
- moet u weten dat een kat 4 poten heeft, 2 ogen, een staart en een vacht. U hoeft niet te weten welke kleur de ogen of de vacht heeft. U hoeft ook niets te weten over de lengte van de staart om een kat te tekenen. Deze specifieke details heeft u niet nodig om een kat te teken (misschien wel om een specifieke kat te tekenen, een Garfield, maar dit was het probleem niet, de opdracht was niet “teken een Garfield”, de opdracht was “teken een kat”).
Om een kat te tekenen houdt u dus uiteindelijk 4 eigenschappen over:
- 4 poten
- een staart
- een vacht
- 2 ogen
Met deze 4 eigenschappen kunt u aan de slag om een kat te tekenen, zij vormen het model van een kat (voor de filosofen onder ons, het “Platonische idee” van een kat).
Waarom is abstractie belangrijk?
Abstractie stelt u in staat om een algemeen idee van wat het probleem is te creëren en hoe het kan opgelost worden. Tijdens het abstractieproces worden alle patronen de niet bijdragen tot de oplossing (het miauwen) en alle specifieke details (de kleur van de vacht) verwijderd. Dit helpt om u een idee te vormen van het probleem. Dit idee wordt een model genoemd.
Indien u geen abstractie had toegepast, en geen specifieke details (zoals de roze kleur van de vacht, de groene kleur van de ogen en de lengte van de staart) had weggelaten, bij het opstellen van het model van een kat, had u misschien tot het idee kunnen komen dat alle katten een roze vacht hebben, een korte staart en groene ogen, vermits deze specifieke details verkeerdelijk zouden deel uitmaken van uw basismodel van wat een kat is.
Abstraction is the gathering of the general characteristics we need and the filtering out of the details and characteristics that we do not need.
Terug naar de problemen “Een appeltaart bakken” en “Een chocoladetaart bakken”.
Door patroon herkenning had u al een aantal gemeenschappelijke kenmerken tussen het bakken van de taarten vastgesteld.
- De oven moet voorverwarmd worden op een aantal graden.
- Iedere taart bevat ingrediënten die in een juiste hoeveelheid gemengd moeten worden.
- Iedere taart moet een bepaalde tijd in de oven.
Door abstractie verwijdert u verder specifieke details en houdt u algemene eigenschappen over.
Om een taart te bakken:
| Algemeen patroon | Specifieke details |
|---|---|
| U moet weten dat de oven moet voorverwarmd worden. | Hoeveel graden |
| U moet weten dat een taart ingrediënten bevat die in een exacte hoeveelheid dienen gemengd te worden. | Welke ingrediënten en hoeveel u moet mengen. |
| De taart moet een tijdje in de oven baken. | Hoelang |
De specifieke details krijgen pas een invulling, een waarde, op het moment u een specifiek taart wilt bakken (bv. een chocoladetaart).
Wat is het model dat gecreëerd wordt door abstractie?
Vertrekkend van onze voorbeelden, een model kat kan gelijk welke kat zijn. Dus niet een specifieke kat met een roze vacht en een lange staart. Het model vertegenwoordigt alle katten. Vanuit het model van katten kan dan afgeleid worden hoe een kat eruit kan zien, gebruikmaken van het patroon dat alle katten delen.
Een model taart is dus niet een specifiek taart zoals een chocoladetaart of een appeltaart. Het model vertegenwoordigt alle taarten. Vanuit het model kan dan afgeleid worden hoe een taart gebakken moet worden, gebruikmakend van het patroon dat geldt voor alle taarten.
A model is a general idea of the problem we are trying to solve.
Opmerkingen
- Merk op dat abstractie hand in hand gaat met het op te lossen probleem. In bovenstaand voorbeeld wordt abstractie genomen van het “miauwen”, omdat het probleem is “Teken een kat”. Het miauwen van de kat werd dus niet opgenomen in het model van de kat. Had nu de opdracht geweest “Maak een plaat met kattengejank”, tja, dan had u zeker geen abstractie genomen van het gemiauw maar wel van de vacht, de poten, de ogen en….
- Vele programmeertalen, vooral objectgeoriënteerde programmeertalen, implementeren het werken op basis van een model. Een objectgeoriënteerde programmeertaal, zoals Java en C#, kennen het begrip “klasse” waarin de algemene kenmerken (en methoden) van de objecten gedefinieerd zijn. Deze “klasse” is te vergelijken met het model zoals hier besproken.
Algoritmen/algorithms in detail
Een algoritme is een plan, een reeks instructies die stap voor stap beschrijven hoe een probleem opgelost kan worden.
Algorithms are one of the four cornerstones of Computer Science. An algorithm is a plan, a set of step-by-step instructions to solve a problem.
Een algoritme moet duidelijk zijn, het moet een beginpunt hebben, een eindpunt en een eindig aantal instructies (stappen) tussen dit begin- en eindpunt.
Voor u een algoritme kunt schrijven moet het probleem duidelijk begrepen zijn. Hiertoe kunnen de 3 voorgaande hoekstenen in het computationeel denken bijdragen. Voor u aan het algoritme begint moeten onderstaande vragen duidelijk zijn:
- Welke gegevens zijn beschikbaar als invoer (input) voor het probleem?
- Wat zal de uitvoer (output) zijn van het probleem?
- In welke volgorde moeten de instructies uitgevoerd worden?
- Welke beslissingen moeten er genomen worden?
- Zijn er onderdelen van het probleem die herhaald moeten worden?
Als al deze vragen beantwoord zijn kunt u het algoritme ontwerpen.
Een algoritme kan ontworpen worden in:
- Pseudocode
- Stroomdiagram (flowcharts)
Een algoritme weergeven in Pseudocode
Computerprogramma’s worden ontwikkeld gebruikmakend van een programmeertaal. Een programmeertaal heeft een specifieke syntax die moet gebruikt worden om de programmeertaal correct te schrijven.
Pseudocode is geen programmeertaal, het is een eenvoudige manier om instructies structureel en begrijpelijk te noteren.
Het schrijven van pseudocode is echter wel vergelijkbaar met het schrijven van programmeercode. Iedere stap van het algoritme wordt in volgorde opgeschreven en er is ook een eenvoudige syntax.
- Instructies worden in hoofdletters geschreven.
- Variabelen in kleine letters.
- Boodschappen worden als een zin geschreven.
Er is geen “officiële” lijst van standaardcode maar onderstaande Pseudocode worden algemeen aanvaard en gebruikt.
| Pseudocode | Betekenis |
|---|---|
| INPUT | De gebruiker voert gegevens in en houdt deze gegevens bij in variabelen. |
| OUTPUT | Gegevens worden weergegeven (op het scherm). |
| IF ... THEN... ELSE ... | Een beslissing/Selectie. Als een bepaalde conditie waar is doe dan dit ander doe dat. |
| WHILE ... | Een lus/iteratie. Zolang een bepaalde conditie waar is doe. |
| FOR ... | Een lus/iteratie. Doe een aantal keer. |
| REPEAT ... UNTIL ... | Een lus/iteratie. Herhaal tot aan een bepaalde conditie voldaan is. |
| STORE | Bewaar een waarde in een variabele (of in een record van een databank). |
Instructie die behoren tot een selectie of een lus worden ingesprongen zodat visueel opvalt dat ze behoren tot die selectie of lus.
Voorbeeld: geef de pseudocode die vraagt naar de naam en het geslacht van de gebruiker en hem nadien gepast welkom heet.
OUTPUT "Wat is uw naam";
INPUT de gebruiker geeft zijn naam in
STORE de ingevoerde naam wordt opgeslagen in de variabele: naam
DO
OUTPUT "Wat is uw geslacht? Geef een 'M' voor man, een 'V' voor vrouw in"
INPUT de gebruiker geeft zijn geslacht in
STORE het ingevoerde geslacht wordt opgeslagen in de variabele: geslacht
While geslacht != 'M' en geslacht != 'V'
IF geslacht = 'M' THEN
OUTPUT "Welkom, meneer " + naam
ELSE
OUTPUT "Welkom, mevrouw " + naam
Een algoritme weergeven in een stroomdiagram (flowcharts)
Een stroomdiagram (flowcharts) is een grafische voorstelling (in diagramvorm) van de verschillende stappen van het algoritme. Een stroomdiagram (flowchart) werkt met een aantal standaardsymbolen.
Merk de symboliek op:
- Een ovaal voor Starten en Stoppen van het programma/script.
- Een parallellogram voor invoer en uitvoer.
- Een rechthoek voor een proces, verwerking/bewerking.
- Een ruit start een beslissing.
- Een beslissing heeft een Ja-kant (waar) en een Nee-kant (onwaar).
Voorbeeld: geef het stroomdiagram dat vraagt naar de naam en het geslacht van de gebruiker en hem nadien gepast welkom heet.
Eens het algoritme vast ligt kan dit algoritme gebruikt worden voor het programmeren van het computerprogramma. De instructies van het algoritme worden stap voor stap “vertaald” in de juiste instructies van de gekozen programmeertaal.
De oplossing evalueren
Computationeel denken helpt u een problemen op te lossen door een oplossing te bedenken, een algoritme, dat kan geprogrammeerd worden.
Als de oplossing echter niet correct (of niet compleet) is dan zal het uiteindelijke programma het probleem niet, niet efficiënt, of, nog erger, verkeerd oplossen.
Voor de oplossing, het algoritme, kan geprogrammeerd worden moet eerst worden nagegaan of de oplossing correct en efficiënt is en of die eventueel nog kan verbeterd worden. Dit gebeurt via een evaluatie.
Evaluation is the process that allows us to make sure our solution does the job it has been designed to do and to think about how it could be improved.
Evaluation allows us to consider the solution to a problem, make sure that it meets the original design criteria, produces the correct solution and is fit for purpose – before programming begins.
In een groter bedrijf zijn de personen die het algoritme opstellen, meestal de analisten, niet noodzakelijk dezelfde mensen die het programma programmeren. De analisten leveren het algoritme, de programmeurs vertalen dit algoritme, via programmeercode, naar een programma dat door een computer kan worden uitgevoerd. Deze programmeurs zullen zich niet de vraag stellen of het algoritme dat ze ontvangen het probleem effectief en het meest efficiënt oplost. Ze doen als het ware niet meer dan het algoritme omzetten in programmeercode.
Bijvoorbeeld, als het probleem “Teken een kat” niet correct wordt opgelost voor de programmeurs, met het ontvangen algoritme, aan het programmeren slaan zou er wel eens een konijn te voorschijn kunnen komen!
Wat kan er zoal fout lopen?
- Het probleem is niet volledig begrepen. Het probleem is niet correct ontleed (decomposition).
- De oplossing is niet volledig. Sommige delen van het probleem zijn niet opgelost.
- De oplossing is niet efficiënt. De oplossing is te complex of te lang.
- De oplossing beantwoordt niet aan de originele ontwerpcriteria (design criteria). De oplossing voldoet niet aan wat gevraagd is.
Een foutieve oplossing bevat één of meerdere van bovenstaande fouten.
Het uiteindelijke algoritme, bekomen na het proces van computationeel denken, moet dus:
- Eenvoudig te begrijpen zijn. Is het volledig ontleed (decomposition)?
- Volledig zijn. Los het algoritme alle aspecten van het probleem op?
- Efficiënt zijn. Maakt het algoritme efficiënt gebruik van de beschikbare bronnen/gegevens en is de oplossing niet te complex of te lang?
- Komt het tegemoet aan de ontwerpcriteria?
Design criteria = Principles and standard that designers should meet in designing a system.
Voorbeelden van mogelijke fouten
Oplossingen die niet juist ontleed zijn
We keren even terug naar de ontleding van het probleem “Taart bakken”. De
- Welke taart wilt u bakken?
- Welke ingrediënten, en hoeveel, hebt u nodig?
- Wanneer moeten de ingrediënten worden toegevoegd?
- Voor hoeveel personen moet de taart zijn?
- Hoe lang moet de taart in de oven staan?
- Op hoeveel graden moet de oven worden voorverwarmd?
- Welk “gereedschap” gebruikt u om de taart te maken?
Het probleem van de “ingrediënten” kan verder ontleedt worden. Schematisch kan dit er als volgt uitzien:
Stel nu dat u het probleem “gereedschap” niet ontleed hebt. Dan zal het algoritme wel aangeven welke gereedschappen er moeten gebruikt worden, maar niet hoe, met welk ingrediënt het “gereedschap” moet worden gebruikt.
Vergeet niet dat een computer “dom” is, als hij niet correct weet hoe hij iets moet doen zal hij het niet goed doen. Het uiteindelijke computerprogramma zou dus zonder de correcte ontleding en bijhorende instructie kunnen de maat nemen met een keukenmes en de boter snijden met een maatbeker!
U moet dus ook het probleem “gereedschap” verder ontleden.
The problem occurred here because the problem of which equipment to use and which ingredients to use it with hadn’t been fully decomposed.
Oplossingen die niet volledig zijn
We keren even terug naar de ontleding van het probleem “Taart bakken”. De
- Welke taart wilt u bakken?
- Welke ingrediënten, en hoeveel, hebt u nodig?
- Wanneer moeten de ingrediënten worden toegevoegd?
- Voor hoeveel personen moet de taart zijn?
- Op hoeveel graden moet de oven worden voorverwarmd?
- Welk “gereedschap” gebruikt u om de taart te maken?
Deze ontleding mist echter een belangrijk punt:
- Hoe lang moet de taart in de oven staan?
Het algoritme weet dus niet dat de taart in de oven moet en hoelang de taart in de oven moet staan en kan hiervoor dus geen oplossing bieden. De kans dat het algoritme de taart gebakken krijgt is dus relatief klein.
The problem occurred here because placing the cake in the oven and specifying the oven temperature had not been included, making the solution incomplete.
PS. Voor alle bakkers in de klas, ben ik nog dingen vergeten, dan is het nu de moment het me te laten weten!
Oplossingen die niet efficiënt zijn
Om de taart te bakken hebben we ingrediënten nodig:
- Welke ingrediënten, en hoeveel, hebt u nodig?
U moet dus ingrediënten gaan halen. U kunt nu zeggen:
- Voor ingrediënt 1, ga naar de kast, neem het ingrediënt en breng het naar de tafel.
- Voor ingrediënt 2, ga naar de kast, neem het ingrediënt en breng het naar de tafel.
- Voor ingrediënt 3, ga naar de kast, neem het ingrediënt en breng het naar de tafel.
Schematisch ziet er dit als volgt uit:
Zou het niet efficiënter zijn om te zeggen:
- Ga naar de kast, neem alle nodige ingrediënten en breng ze naar de tafel.
De oplossing is nu eenvoudiger en efficiënter. Het aantal stappen is teruggebracht van 9 naar 5.
The problem occurred here because some steps were repeated unnecessarily, making the solution inefficient and overly long.
De oplossing voldoet niet aan de ontwerpcriteria (design criteria)
Op het probleem (de vraag):
- Welke taart wilt u bakken?
is het antwoord: een “Een chocoladetaart bakken met slagroom en afgewerkt met hagelslag”. Het ontwerp wordt dus duidelijk gespecificeerd.
Het ontwerpcriteria is hier “een chocoladetaart met slagroom, afgewerkt met hagelslag”.
Als onze uiteindelijke taart teveel naar appeltaart smaakt is er niet echt voldaan aan het ontwerpcriteria.
The problem occurred here because the solution did not meet the original design criteria – it was not exactly what was requested.
Hoe evalueert u de oplossing?
Om zeker te zijn dat de oplossing correct is, stel de volgende vragen:
- Begrijpt u volledig hoe u het probleem moet oplossen?
Zolang het probleem niet volledig begrepen is moet u terugkeren naar de ontleding. Pas wanneer u het probleem volledig begrijpt en weet hoe het kan opgelost worden eindigt de ontleding. - Is de oplossing volledig?
Even terug naar het probleem “Teken een kat”. Hebt u echt voldoende aan 4 poten, 2 ogen, een vacht en een staart om een kat te tekenen (heeft een kat bv. ook geen snorharen, oren,…). Zolang de oplossing het probleem niet volledig oplost blijft u stappen (eigenschappen/kenmerken in dit geval) toevoegen. - Bevat de oplossing stappen die zich herhalen?
Verwijder herhalende stappen zodat de oplossing efficiënter wordt.
Dry runs
Een van de beste manieren om een oplossing te testen is via een zogenaamde “Dry run”. Dit is het eenvoudigste indien het algoritme uitgetekend is in een stroomdiagram (flowchart). Met pen (en eventueel papier) doorloopt u algoritme (het stroomschema) en gaat u na of het gewenste pad gevolgd wordt.
Test ook alle mogelijke uitzonderingen. Bv. Als u vraagt “Wat is uw geslacht? Geef een ‘M’ voor man, een ‘V’ voor vrouw in.” en de gebruiker zou een andere letter intypen, levert het algoritme dan ook nog een correcte oplossing op? Meer concreet, vraagt het algoritme, bij een niet correcte invoer, om de invoer te herhalen?
Levert het manueel volgen van het algoritme niet de gewenste oplossing op, wordt niet het gewenste pad gevolgd, dan zit er een fout in het algoritme en moet u weer naar de “tekentafel”. Maar, door de “dry run” weet u nu waar het fout loopt!
Dry runs are also used with completed programs. Programmers use dry runs to help find errors in their program code.
Hoe Google computationeel denken in de praktijk toepast
Onderstaande video’s toont hoe Google computationeel denken in de praktijk toepast.
Computationeel denken en Google Maps
Computationeel denken en Google Foto’s
Computationeel denken en YouTube videobewerking
Computationeel denken en Google’s Game API
Computationeel denken en Google’s internet
Computationeel denken en Google’s rampenplan
Behandelde Basiscompetenties uit de module ICT Programmeren – Start to program
- IC BC230 – heeft inzicht in de processen achter het computationeel denken
- IC BC344 – kan oplossingen voor eenvoudige probleemstellingen bedenken
- IC BC023 – kan ICT aanwenden om problemen op te lossen
Software developers likes to solve problems.
If there are no problems handily available
they will create their own problems.
