opa vertelt … Programmeren (deel 1)

In de serie “opa vertelt” vertelde ik eerder al iets over programmeren. Nu ga ik daar wat uitgebreider op in.

Ik heb leren programmeren in Pascal met ponskaarten op een Control Data Cyber 170/760.
Dat ging zo: nadenken over het algoritme, uitschrijven op papier, intikken via een kaartponser, ponskaarten naar de rekenhal-balie brengen en een uurtje of zo later in de uitvoerkast onder de letter S kijken wat je programma voor uitvoer had geproduceerd. Als het tegenzat, kwam je niet verder dan een “syntax error in line 5” zodat je de 5de ponskaart ertussen uit haalde en alsnog die ontbrekende puntkomma toevoegde.
Omdat er zo’n lange tijd zat tussen “inkloppen” (zou dat woord komen uit de ponstijd: de toetsen van een ponsmachine waren inderdaad zwaarder dan van een typemachine lastig te bedienen) en uitvoer terugzien, moest je noodgedwongen wel goed nadenken.

Overigens was er in die tijd, ik spreek over eind jaren zeventig, nog geen studie informatica, maar was programmeren een “bijvak” binnen de wiskundestudie. In mijn doctoraalfase (ongeveer het huidige masters) werd ik studentassistent bij prof. Jan Willems en assisteerde bij colleges over systeemtheorie (In die tijd was je dus assistent bij een hoogleraar en niet bij een opleidingsinstituut!). Mijn afstudeerwerk was ook bij Jan en kwam neer op het uitprogrammeren van algoritmen op het gebied van lineaire systemen.
Daarvoor heb ik een programma Lidia geschreven (LInear systems DIsturbance decoupling Algorithms) waarin door prof. Wonham bedachte theorie in de praktijk kon worden uitgevoerd. Lidia was geschreven in Algol68. Die taal kende een zeer uitgebreide syntaxdefinitie, die ook een groot deel van de semantiek bevatte. Zo waren de syntaxdefinities zo opgesteld dat daaruit bleek dat je bijvoorbeeld een variabele eerst moest declareren voordat je hem kon gebruiken. Deze manier van noteren werd de context free grammar genoemd. De syntax definities van Algol68 besloegen dan ook een compleet boekwerk en waren feitelijk nauwelijks te lezen.
De Algol68-compiler op de Cyber was de beste ter wereld, maar toch niet foutloos. Regelmatig heb ik bij Doeke de Vries gezeten, toendertijd werkzaam bij het rekencentrum van de RUG (later nog een tijd bij informatica als docent en programmeur) waarbij steeds weer opnieuw compilerfouten werden opgespoord, geisoleerd in een kleinst mogelijk stuk code en naar CDC opgestuurd. Vaak binnen een week was er dan een patch voor de compiler, maar niet zelden leidde dat weer tot een andere compilerfout.
In die tijd (1981-1982) kon je al via een terminal met de Cyber communiceren. Een sessie duurde echter maximaal 45 minuten en in die 45 minuten moest ik aan de hand van een zelfgemaken load tabel aangeven welke onderdelen van mijn programma gelijktijdig in het (toen nog beperkte) geheugen van de Cyber aanwezig konden zijn en welke tijdelijk even “uitgeswapt” mochten zijn. Het laden van die tabel plus alle code en het vertalen ervan kostte zo’n 20 minuten. In een sessie kon ik dus net eenmaal mijn aanpassingen testen. Niks geen interactiviteit dus…

Ter illustratie: bij terminalgebruik van de Cyber was het maximale geheugengebruik toen 120.000 woorden (een Cyberwoord was 60 (dus geen macht van 2) bits groot). De gehele Lidia-applicatie moest, omdat het anders veel meer geheugen zou gebruiken, worden opgeknipt met een segmentloader. Omdat zelfs dan de afhankelijkheid van methoden zou kunnen zorgen voor een overload werd ervoor gekozen dat procedures elkaar niet direct konden aanroepen maar gegevens via globale variabelen aan elkaar doorgaven.
Het totale Lidia-pakket was 3153 regels groot, de grootst mogelijke geheugenruimte (dank zij die segmentloader) was 71732 words. Het resterende geheugen was nodig om de gegevens (globale variabelen) te kunnen opslaan. De zwaarste berekening vergde 7 cp-seconden. Een terminalsessie kende toendertijd een limiet van 16 cp-seconden (een cp-seconde is één seconde zuivere cpu rekentijd). De keuze voor Algol68 was ingegeven omdat dan gebruik gemaakt kon worden van Torrix, een bibliotheek van vector- en matrix routines.

In dezelfde periode was het al mogelijk, via een telefoonlijn, gebruik te maken van een DEC PDP-10 in Twente. Deze DEC-10, had, i.t.t. de Cyber, zg. virtueel geheugen en daarmee niet de geheugenbeperking zoals hierboven beschreven. Op deze DEC-10 werden, zij het beperkt, vanuit Groningen via een telefoonlijn enkele programmeerpractica uitgevoerd. Rond 1975 waren Groningen en Twente dus al digitaal verbonden.

Na mijn afstuderen kon ik zes jaar door aan de RUG met het enerzijds opzetten van een opleiding informatica en anderzijds met promotieonderzoek op het grensvlak van systeemtheorie en informatica.

In Groningen had de vakgroep informatica toen de beschikking over een PDP-11. Deze op Unix draaiende machine moest worden opgestart door eerst een zg. bootstrap code in te tikken, dan een ponsband te laten inlezen en uiteindelijk was de machine in staat om van magneetband de rest in te lezen en programma’s te draaien.

In die tijd werd natuurlijk gewerkt aan het verder ontwikkelen van colleges op het gebied van programmeren. Naast het imperatief programmeren (in Pascal) kwamen ook functioneel en logisch programmeren aan bod.
Bij imperatief programmeren was devide and conquer het toverwoord: problemen opsplitsen in kleinere en uiteindelijk de kleinste problemen middels een Pascal-procedure uitwerken. Recursie werd veel gebruikt en daarnaast was er veel aandacht voor data structuren en data abstraction.

In tegenstelling tot nu gingen ook de beginnende programmeervakken al diep in op allerlei datastructuren zoals lijsten, bomen, gebalanceerde bomen enz. Hierbij waren pointers in Pascal onontbeerlijk. Er was in Pascal geen automatische garbage collection, dus moest je zo programmeren dat een niet langer gebruikt stuk data ook werkelijk weer werd vrijgegeven zodat het opnieuw gebruikt kon worden. Te vroeg vrijgeven leidde tot overschrijven van data die nog in gebruik was, niet vrijgeven tot heap overload.
Daarnaast was er in die tijd, ook veel meer dan nu, aandacht voor zoek- en sorteeralgoritmen: lineair search, bubblesort, quicksort e.d.

Omdat informatica als opleiding uit de wiskunde-opleiding geboren was, werd er toen veel (veel meer dan nu) aandacht besteed aan programmacorrectheid. De Hoare-tuples, pre- en postcondities en de invarianten bij een herhaling werden lang en uitgebreid geoefend.

In een volgend deel over programmeren zal ik het hebben over modulair pascal (modpas), simuleren in modpas en de ontwikkeling van oo-talen.

Getagd met ,