Programmeren met spreadsheets

Programmeren met spreadsheets

De meeste toepassingen worden geprogrammeerd met behulp van spreadsheets. De drempel voor het maken van een eenvoudige spreadsheet is erg laag: binnen enkele minuten heb je al je eerste resultaat. Een groot voordeel is dat alle stappen in een berekening zichtbaar zijn, en dat je direct het resultaat van je aanpassingen ziet. Bovendien is het rekenmodel van spreadsheets eenvoudig: in de wereld van programmeertalen zou je dit een eenvoudige functionele taal kunnen noemen.

Aan de hand van verschillende voorbeelden leggen we een aantal principes van programmeren uit. We kunnen op twee manieren kijken naar een programma:

Programma beschrijft berekening

Een programma beschrijft een berekening. Vaak is dit een samengestelde berekening, met tussenresultaten.

In dit geval zijn we vooral geïnteresseerd in het resultaat van de berekening. De precieze volgorde van de stappen om tot het resultaat te komen is daarbij niet van belang.

Programma beschrijft proces

Een programma beschrijft ook vaak een proces. Een proces speelt zich af in de tijd, en bestaat uit een reeks stappen die achtereenvolgens uitgevoerd worden door de processor. Deze processor kan een automaat zijn, zoals een computer, maar ook een mens. Het programma beschrijft steeds wat de volgende stap is, op basis van het programma (de beschrijving van het proces), de toestand van het proces, en de invoer. De toestand van een proces omvat de positie in het programma en een reeks variabelen met tussenresultaten.

Deze begrippen werken we in de voorbeelden verder uit.

Beperkingen van spreadsheets

• fouten in spreadsheets zijn lastig te vinden;
• spreadsheets zijn niet "schaalbaar" - noch voor grotere berekeningen, noch voor grotere hoeveelheden data.

Onderwerpen

• /Spreadsheets-basis
• /Voorbeeld: groeiprocessen

Voorbeeld: groeiprocessen

Processen met groei (of krimp) kom je overal tegen:

• de hoeveelheid geld op een bankrekening
• de groei van bacteriën op een voedingsbodem
• de groei van het aantal (mogelijke) verbindingen in een netwerk
• het vollopen van een emmer water onder een kraan
• het leeglopen van een vat met water via een kraan onderin
• en veel andere vergelijkbare voorbeelden.

Deze groei hoeft niet altijd een functie van de tijd te zijn: in de informatica gebruik je het begrip complexiteit om aan te geven hoe de hoeveelheid rekenwerk afhangt van de omvang van het probleem. Voor verschillende algoritmen groeit de hoeveelheid rekenwerk verschillend bij eenzelfde toenamen van de omvang van het probleem.

Het triviale model is *nulgroei*: de hoeveelheid H blijft gelijk.

Lineaire groei

Het eenvoudigste niet-triviale model is lineaire groei: de hoeveelheid H neemt elke stap met een constante toe: $H(t_{n+1})=H(t_{n})+K$. Of ook wel: $H(t+\Delta )=H(t)+K\cdot \Delta$

We kunnen dit groeiproces eenvoudig in een spreadsheet weergeven:

• de eerste kolom (A) geeft de tijd (of het nummer van de stap) weer: $t$; we beginnen, zoals gebruikelijk in de informatica, bij 0.
• de eerste rij beschrijft de begintoestand: $H(0)$, in kolom B
  • C1 bevat de constante </math>K</math>
• elke volgende rij heeft dezelfde formule: =B1 + $C$1

Voorbeelden:

• lineair zoeken

Kwadratische groei

Voorbeelden:

• netwerken (van internet tot Facebook etc.): het aantal mogelijke (directe) verbindingen; wet van Metcalfe (over de waarde van een netwerk)
• (minder slimme) sorteeralgoritmen

Exponentiële groei

Voorbeelden:

• rente (samengestelde interest, "rente op rente")
• sommige rekenprocessen (algoritmen): bijvoorbeeld Traveling Salesman, SAT (voor welke waarden van de logische variabelen levert een bepaalde logische uitdrukking true op?)

Logaritmische groei

Voorbeelden:

• binair zoeken