Artikel uit Kennisgeving, jrg. 9, nr 2, november 1996, pp. 4-5
Een bijzondere vorm van programmeren.
'Tusschen droom en daad staan wetten in den weg en praktische bezwaren.' Willem Elsschot
In het boekje 'Over Micro-Elektronica' van Hans de Witte, uitgegeven door de Staatsuitgeverij in 1980, staat op blz.20 de volgende zin: "Microprocessoren kunnen de opgeslagen informatie foutloos en snel bewerken, zij het uitsluitend op basis van een programma dat in het algemeen door mensen moet zijn gemaakt.'
Het opmerkelijke in deze uitspraak is dat de mogelijkheid dat het programma anders dan door mensen moet zijn gemaakt niet geheel wordt uitgesloten.
Men kan zich voorstellen dat in een BASIC-programma een BASIC-regel wordt gegenereerd en in een stringvariabele wordt opgeslagen. Nu is het probleem van BASIC dat deze string wel op het scherm kan worden afgedrukt, maar niet kan worden uitgevoerd. Met andere woorden de aanwezige BASIC-interpreter is niet bereikbaar. Een oplossing zou zijn een BASIC-interpreter in BASIC te schrijven. Echter het is zelfs theoretisch de vraag of een volledige BASIC-interpreter, die ook nog de variabelen met de oorspronkelijke interpreter moet delen, in BASIC geschreven kan worden. Wel is het mogelijk de bestaande interpreter uit te breiden met een statement 'DO <stringexpressie>'. Dit laatste heb ik bij mijn in 1979 aangeschafte EXIDY-computer gedaan door de BASIC-interpreter te disassembleren, een stukje code toe te voegen en vervolgens weer te assembleren. (1984)
Een van de redenen om dit DO-statement te implementeren wordt hieronder weergegeven. De twee stel BASIC-regels doen hetzelfde, mits de invoer aan de gestelde voorwaarden voldoet.
10 rem Voorbeeld 1
20 clear999
30 print"Voer een num. expressie in met de tekens";
35 print" 0 t/m 9 en + en -."
40 AA$="":input"??? ";AA$
50 B=0
60 P=pos(2,AA$,"+"):Q=pos(2,AA$,"-")
65 ifP>QthenR=P:P=Q:Q=R
70 ifP=0thenP=Q:ifP=0thenB=B+val(AA$):goto90
80 B=B+val(left$(AA$,P-1)):AA$=mid$(AA$,P):goto60
90 print"Het resultaat is "B:goto30
100 rem Voorbeeld 2
110 clear999
120 print"Voer een num. expressie in met de tekens";
125 print" 0 t/m 9 en + en -."
130 AA$="":input"??? ";AA$
140 do"B="+AA$
150 print"Het resultaat is "B:goto120
De vergelijking van de regels 50 t/m 80 met 140 laat zien hoe krachtig dit DO-statement is.
Toen ik in 1992 een 'echte' PC aanschafte miste ik bij QBASIC en ook bij batch-programma's een soortgelijke mogelijkheid.
Het DO-statement is te vergelijken met het EVAL-statement in LISP. In het boek LISP van P.H. Winston en B.K.P. Horn wordt in het geheel geen aandacht geschonken aan het bijzondere van het EVAL-statement.
Een vluchtige oriëntatie bij de Open Universiteit (open dag 1994) en de Universiteit van Amsterdam (voorlichtingsdag 1996) om achter de theorie van een en ander te komen had tegen mijn verwachtingen in geen resultaat. Bij de hierboven genoemde voorbeelden koos men zonder meer voor voorbeeld 1, het voorbeeld met het DO-statement vond men niet correct. Ik kreeg de indruk dat bij deze instellingen dit (nog) niet als een wetenschappelijk probleem herkend wordt.
Ook in de literatuur wordt, bij de beschrijving van de Turing-machine, geen gewag gemaakt van de mogelijkheid dat de machine zijn eigen programma beïnvloedt.
Het is misschien ook wel begrijpelijk dat de wetenschap dit over het hoofd ziet, immers de theorie over computers dateert van zestig jaar geleden toen de voorhanden zijnde techniek duur, traag en onbetrouwbaar was. Pas met de moderne computer werd het concept van stored-program gerealiseerd. Voor die tijd was het programma opgenomen in de hardware. Ter verduidelijking, bij stored-program staan niet alleen de gegevens (data), maar ook het programma in het computergeheugen.
Mijn eigen kijk hierop is het volgende.
Een BASIC-interpreter kan ook gezien worden als een subroutine die een BASIC-statement, een BASIC-regel of een BASIC-programma als argument meekrijgt. Er is niets op tegen dat deze subroutine vanuit diezelfde subroutine wordt aangeroepen. Dat wordt ook wel recursieve aanroep genoemd. Was de theorie van de informatica misschien al helemaal afgerond, nu kan een heel nieuw terrein betreden worden. Dat deze vorm van recursie bij BASIC mogelijk is komt doordat BASIC de stringvariabele kent. In een string laat zich met gemak een BASIC-statement of -regel opslaan. Het wordt nu ook duidelijk dat het begrip taal uit twee delen bestaat:
- De statements, die aaneengeregen kunnen worden tot een programma.
- De interpreter(-subroutine), die opnieuw in twee delen gesplitst kan worden, eventueel enz. enz., totdat het hardwareniveau bereikt wordt.
Maar omgekeerd kan met het DO-statement taal gecreëerd worden met als interpreter een BASIC-programma.
Een ander probleem met eenzelfde soort oplossing kan wat meer duidelijkheid verschaffen. Een eenvoudige computer (bijv. de EXIDY of TRS80) start bij het aanzetten met een MONITOR-programma waarin verschillende commando's kunnen worden uitgevoerd. Met een van die commando's is ook BASIC bereikbaar. Vanuit BASIC kan weer teruggegaan worden naar de MONITOR met het commando 'BYE'. Met een aanpassing in de BASIC-interpreter is het statement 'BYE <string-expressie>' mogelijk. Het MONITOR-commando in de string-expressie wordt dan door de MONITOR-interpreter uitgevoerd en hierna wordt de uitvoering van het BASIC-programma voortgezet. De inhoud van de stringexpressie wordt volledig door het BASIC-programma bepaald. In het BASIC-statement staat bijvoorbeeld
bye"SA "+NM$+" 8000 "+L$
In NM$ staat 'ABCDE' en in L$ '9EFF'. De MONITOR voert dan het commando 'SA ABCDE 8000 9EFF' uit. (Schrijf de inhoud van de geheugenplaatsen 8000H t/m 9EFF weg naar het externe opslagmedium en geef ze daar de naam ABCDE.)
Het behoeft geen betoog dat het niet eenvoudig is om hetzelfde zonder BYE-statement te programmeren.
De statements 'BYE <stringexpressie> en 'DO <stringexpressie>' zijn wat werking betreft gelijk. BYE en DO hebben als interpreter respectievelijk de MONITOR en BASIC. Bij 'DO' wordt gesproken van recursie omdat 'DO' van BASIC naar BASIC werkt. 'BYE' zowel als 'DO' hebben iets van het 'RUN'-statement, het commande opgeslagen in de string wordt uitgevoerd, 'de gedachte wordt daad'.
Het was een groot gemis dat een MONITOR-commande of een los BASIC-statement of -regel alleen via het toetsenbord uitgevoerd kon worden.
Leek het principe van stored-program al een overeenkomst met het menselijk brein te hebben, bij de vorm van programmeren met het DO-statement dringt zich dat nog sterker op.
Het principe van het DO-statement kan wellicht de grondslag vormen voor een programma om het menselijk redeneren te imiteren.
Voor kunstmatige intelligentie kan dit DO-statement bijvoorbeeld gebruikt worden om een door een genetisch algoritme gegenereerde formule te testen.
Het is niet uitgesloten, dat een computerprogramma door dit DO-statement volkomen autonoom (zelfstandig) wordt. Dit kan een gevaar worden bij robotachtige toepassingen. Het is al voorgekomen dat mensen per ongeluk door een robot gedood werden. Met dit DO-statement is 'moord met voorbedachte rade' door de robot te verwachten.
Kortom met de hier beschreven vorm van programmeren kan de computer een geduchte concurrent voor de mens worden.
[Hoewel hier op eenvoudige wijze het nut van het 'DO-statement' is geschetst, raakt deze kwestie waarschijnlijk de grondslagen van de wiskunde en informatica. Ik vermoed dat een en ander samenhangt met de 'grundlagenstreit' die zich in het begin van de twintigste eeuw tussen wiskundigen van naam afspeelde. Gezien de vaak enigzins emotionele reactie die ik krijg bij de demonstratie van het DO-statement, is die strijd nog altijd actueel.]
Henk Palstra
LITERATUURLIJST
- Hans de Witte
Over Micro-elektronica
Staatsuitgeverij 1980
ISBN 90 12 62871 X - David Harel
Algoritmiek, de essentie van de informatica
Academic Service 1989
ISBN 90 6233 328 1 - Patrick Henry Winston en Berthold Klaus Paul Horn
LISP
Addison-Wesley 1981
ISBN 0-201-08329-9 - D. van Dalen
Filosofische gronslagen van de wiskunde
Van Gorkum, Assen/Amsterdam 1978
ISBN 90 232 1540 0
