Inhoud

Hoewel het kernprogramma van informatica imperatief programmeren als uitgangspunt neemt, hebben leerlingen de mogelijkheid om zich te verdiepen in alternatieve programmeermodellen’s in een keuzethema. In deze cursus bestuderen we declaratieve programmeermodellen. Dat wil zeggen: programmeermodellen die de computer niet vertellen hoe we ons doel willen bereiken (imperatief), maar simpelweg wat we willen bereiken (declaratief). Dit zorgt voor een heldere en compacte programmeerstijl.
Na een overzicht van programmeermodellen in het algemeen, en de verschillen tussen imperatief en declaratief programmeren, duiken we in vier modellen: functioneel programmeren, reactief programmeren, concurrent programmeren en logisch programmeren.
Functioneel programmeren kenmerkt zich door het gebruik van pure functies en onveranderlijke datastructuren. Hierdoor weten we dat onze programma’s geen onverwachte zijeffecten kunnen vertonen. Het gevolg is dat we makkelijker over onze programma’s kunnen redeneren. Daarnaast zorgt een sterk typesysteem er voor dat geschreven programma’s van nature correct zijn, niet zullen falen tijdens de uitvoer, en dat herstructureren van code eenvoudiger is.
Reactief programmeren is bedacht om, ondanks pure functies, toch interactie te hebben met eindgebruikers en op een elegante manier de toestand van een applicatie te beheren.
Concurrent programmeren is een methode om een proces op te splitsen in meerdere taken. Bij het werken met meerdere taken, komt de verantwoordelijkheid van de programmeur om tussen deze taken te communiceren en te synchroniseren. We behandelen twee basale methoden om dit te doen: door geheugen te delen en door berichten uit te wisselen. We zullen ook zien wat er gebeurd wanneer we er geen rekening mee houden dat taken gelijktijdig worden uitgevoerd of racen voor hun gedeelde bronnen.
Logisch programmeren stelt ons in staat berekeningen te maken aan de hand van relaties. We schrijven programma’s door een databank van feiten en regels op te stellen, en deze databank vervolgens te ondervragen.
Al deze programmeermodellen vereisen een radicaal andere manier van denken bij het ontwikkelen van, en redeneren over programma’s. Vaardigheden die helpen bij het oplossen van een breed scala aan problemen. Elk onderdeel van deze cursus wordt afgesloten met een tussentoets, sommige theoretisch, sommige praktisch van aard.
Doelen

• De kenmerken van imperatief en declaratief programmeren evalueren.
• Functionele, reactieve, concurrente en logische programma’s evalueren en ontwikkelen.
• Onderstaande concepten begrijpen en toepassen.

(Gedetailleerde leerdoelen zijn te vinden bij elke leertaak.)
Concepten

• expressies, waardes
• (hogere orde) functies
• herschrijven
• partiële functie applicatie (currying)
• anonieme functies (lambdas)
• (algebraïsche) data types
• onveranderlijkheid (immutability)
• puurheid, referentiële transparantie
• recursie
• type, type systeem, type inferentie
• polymorfie
• interactie
• zijeffecten
• model-view-update
• commando’s, subscripties
• concurrency, parallelisme, gedistribueerdheid
• atomische operatie, mutex
• kanaal, bericht
• relaties, feiten, regels
• ondervragingen

Ervaring met de basiselementen uit programmeertalen is gewenst. Het gaat om begrippen als keuze, herhaling, recursie, functie en procedure, zoals behandeld bij een cursus imperatief programmeren. Kennis van object-georiënteerd programmeren is zeker niet nodig. Kennis van HTML en CSS komt van pas maar zijn niet noodzakelijk.

De cursus is taakgestuurd opgezet. Er is een tweewekelijkse cyclus van oriëntatie (hoorcollege), zelfstudie en nabespreking (responsiecollege).

Bijeenkomsten

Elke twee weken hebben wij een bijeenkomst van 3 uur, waarbij we gedurende
het eerste uur reflecteren op de opdrachten van de vorige keer (responsiecollege), en
de volgende twee uren nieuwe stof behandelen (hoorcollege).
Het bespreken van de opdrachten doen we aan de hand van jullie eigen ingeleverde werk. Het behandelen van nieuwe stof doen we interactief: de docent geeft een overzicht van concepten, ideeën, en toepassingen waarbij ruimte is voor tussentijdse opdrachten, vragen, en discussie.

Zelfstudie

Na iedere bijeenkomst gaat iedereen aan de slag met de leertaken. Deze bestaan uit zowel lees- als werkopdrachten. Elke leertaak heeft een vaste structuur, waarin de leerdoelen en de aan te leveren producten zijn gespecificeerd. De producten dienen 48 uur voor de volgende bijeenkomst ingeleverd te worden via de elektronische leeromgeving, zodat wij die tijdens de volgende bijeenkomst kunnen behandelen.

Tijdens de zelfstudieperiode is het mogelijk om vragen te stellen op het forum. Maak hier goed gebruik van! Schroom niet om uw medestudenten te helpen waar u kunt. Uiteraard zal de docent hierin helpen en sturen.

De bijeenkomsten vinden plaats op locatie bij Boswell Beta in Utrecht. Bij striktere Corona maatregelen zullen we uiteraard uitwijken naar digitale bijeenkomsten.

Online lesmateriaal op digitale leeromgeving

De tentaminering van de cursus bestaat uit vier tussentoetsen:

1. Functioneel programmeren is een schriftelijk huiswerktentamen. Hierbij mag u gebruik maken van alle middelen die wij tijdens de cursus hebben gebruikt. Dat geldt ook voor materiaal op internet. Je dient het tentamen wel zelf te maken. Hulp van je medestudenten is niet toegestaan!
2. Reactief programmeren is een groepsprogrammeeropdracht. Je ontwikkelt samen met een medestudent een interactieve webapplicatie. Je krijgt hiervoor een aantal weken de tijd. Hierbij mag je gebruik maken van alle leermiddelen, online materiaal en kunt je vragen stellen en ervaringen uitwisselen op het forum van de elektronische leeromgeving.
3. Concurrent programmeren is weer een schriftelijk huiswerktentamen waarbij je gebruik mag maken van alle beschikbare middelen. Alleen samenwerken is weer niet toegestaan.
4. Logisch programmeren is een informeel groepsgesprek over de toepassing van de geleerde programmeermodellen binnen het voortgezet onderwijs. Hierin wordt een active houding gevraagd aan alle deelnemers.

Aan het einde van de cursus vind met iedere deelnemer een individueel mondeling plaats van 20 minuten. We bespreken samen uw huiswerktentamens en groepsopdracht. Hoewel dit gesprek onderdeel is van de toetsing, heeft het een karakter van een inhoudelijke (werk)bespreking van collega-programmeurs.
Voor onderdelen 1, 2 en 3 krijgt u een cijfer, onderdeel 4 wordt beoordeeld met een voldaan/onvoldaan. Wanneer je voor alle onderdelen minstens een 5½ heeft behaald mag je deelnemen aan het mondeling. Het eindcijfer het gemiddelde van de drie resultaten en het mondeling. In andere gevallen is het eindcijfer het laagste van deze vier. In programmeercode:

fn sufficient(x) { x >=. 5.5 }
fn average(xs) { sum(xs) /. int.to_float(list.length(xs)) }
fn sum(xs) { list.fold(over: xs, from: 0.0, with: fn(x, y) { x +. y }) }
fn minimum(xs) { list.fold(over: xs, from: 0.0, with: float.min) } 
fn endmark(p1: Float, p2: Float, p3: Float, p4: Bool) -> fn(Float) -> Float {
  let prerequisites = [p1, p2, p3]  case list.all(prerequisites, sufficient) && p4 {
    True -> fn(oral: Float) { average([oral, ..prerequisites]) }
    False -> function.constant(minimum(prerequisites))
  }
}

Tim Steenvoorden is Universitair Docent aan de Open Universiteit. Daar verzorgt hij de vakken Functioneel programmeren, Concepten van programmeertalen, Besturingssystemen en Computerarchitectuur. Zijn onderzoeksinteresses liggen op het gebied van het ontwerpen en implementeren van programmeertalen. Zo gebruikt hij gereedschappen als operationele semantiek, type- en effectsystemen, en symbolische executie voor het ontwikkelen van een formele specificatietaal voor workflowsystemen, en het veilig kunnen programmeren van kernel extensies.