Einstieg in LOGO - Universelle Automation

Einstieg in LOGO
von Günther Schättiger
Juni 1999
Einleitung
Die Programmiersprache LOGO ist ein Verwandter von LISP. Somit werden hier eigentlich Funktionen
programmiert, auch wenn die Auflistung der Programme aussieht wie bei einer imperativen Sprache. Was
LOGO von LISP unterscheidet, ist außer der sofort erkennbaren Turtlegrafik (auf deutsch »Igelgrafik«) die
leichtere Erlernbarkeit. Besonders diese Eigenschaft führte zu einer großen Verbreitung an Schulen.
Im folgenden beschreibe ich den Umgang mit dem frei erhältlichen MSWlogo. Dieses stammt aus USA und
die Benutzerführung ist in englisch. Es gibt auch deutsche LOGO-Versionen auf dem Markt, bei denen
auch die Schlüsselworte eingedeutscht sind. So heißt z.B. TO dort LERNE. Diese Eigenart macht es
Kindern vielleicht leichter, das Programmieren zu erlernen, jedoch können diese deutschen LOGOProgramme nicht unter englischsprachigen Interpretern laufen.
Struktur eines LOGO-Programmes
Primitive
Die Befehle und Funktionen, die bereits fest in die Sprache eingebaut sind, heißen bei LOGO »Primitives«.
Aus diesen Primitives setzen sich die Befehle und die selbstdefinierten Prozeduren zusammen. Da
selbstdefinierte Prozeduren wie Primitives verwendet werden, läßt sich auf diese Weise der Sprachumfang
von LOGO erweitern.
Prozeduren
Ein LOGO-Programm besteht aus einer oder mehreren »Prozeduren«. Prozeduren sind für LOGO das,
was bei LISP die Funktionen sind. Sie beginnen mit dem Schlüsselwort TO und enden mit END. Alle
Prozeduren liegen einträchtig nebeneinander im Arbeitsspeicher. Eine Prozedur wird gestartet durch die
Eingabe ihres Namens an der Kommandozeile. Prozeduren können sich auch gegenseitig aufrufen.
LOGO-Objekte
LOGO gehört zu den Sprachen, die nicht oder nur schwach typisieren, d.h., es gibt keine Variablen
unterschiedlichen Typs und keine Variablendeklaration. Statt von »Variablen« spricht man bei LOGO oft
von »Objekten«. Diese haben jedoch nichts zu tun mit objektorientierter Programmierung. Es soll durch die
Bezeichnung nur deutlich gemacht werden, daß es in LOGO die Unterscheidung zwischen Daten und
Programm eigentlich nicht gibt, alles sind nur »Dinger« (things), oder eben Objekte.
Folgende Logo-Objekte gibt es:
•
•
•
Zeichen: ein einzelnes Zeichen. Dies kann ein Buchstabe oder eine Zahl sein.
Wort: eine Reihe von Zeichen. Wörter in LOGO dienen typisch als Bezeichner für Prozeduren
oder Variablen.
Listen: eine Reihe von Wörtern. Sie sind verwandt mit den Listen in LISP. Sie werden in eckige
Klammern geschrieben.
Auch die LOGO-Prozeduren selbst werden intern als Listen gespeichert. Deshalb ist es in LOGO recht
einfach möglich, Programmgeneratoren zu entwickeln oder Programme durch Programme zu manipulieren.
Turtle-Grafik
Berühmt geworden ist LOGO durch die Turtle-Grafik. Manche glauben sogar, LOGO bestehe nur aus der
Turtlegrafik. Das ist zwar nicht richtig, dennoch ist die Turtlegrafik besonders für Kinder und Jugendliche
der erste Einstieg ins Programmieren.
In frühen Implementationen am MIT war die Turtle ein richtiges mechanisches Zeichengerät, eine Art
kleiner Wagen, der vom Rechner über einen Bogen Papier gesteuert wurde. Im modernen LOGO ist es ein
kleines Dreieck, das über den Bildschirm fährt.
Weil die Turtlegrafik in LOGO eine wichtige Rolle spielt, gibt es eine recht große Zahl von Befehlen zum
Steuern der Turtle. Es gibt Kommandos zum Vorwärts- und Rückwärtsbewegen der Turtle, für Drehungen
und Ausrichtung in einem bestimmten Winkel, zum Heben und Senken des Zeichenstiftes und zur Auswahl
von Größe und Farbe des Stiftes.
Anmerkungen zur Syntax
Die Schreibweise eines LOGO-Programmes ist etwas ungewohnt, auch für erfahrene LISPProgrammierer. Ein Befehl besteht aus einem Aufruf eines (internen) Kommandos oder einer
selbstdefinierten Prozedur, meist gefolgt von einem oder mehreren Parametern. Es können mehrere Befehle
auf einer Zeile stehen. Da es keine Klammern um die Funktionen oder ihre Argumente gibt, kann so eine
Zeile leicht etwas unübersichtlich werden. Es empfiehlt sich daher, immer nur einen Befehl pro Zeile zu
schreiben, wenn es geht. Ausnahme: wo geschachtelte Funktionen geschrieben werden, müssen sie auf
einer Zeile stehen.
Die größe Schwierigkeit für Anfänger besteht darin, zu wissen, ob ein LOGO-Wort eine Prozedur ruft, ein
lexikalischer Ausdruck ist oder eine Variable darstellt. Dazu eine einfache Regel:
Jedes LOGO-Wort ohne weitere Zusätze ruft eine eingebaute oder selbstdefinierte Prozedur auf. Bespiele:
PRINT
QUADRAT
Wenn es ein lexikalischer Ausdruck sein soll, so schreibt man vor das Wort ein Anführungszeichen.
Beispiele:
PRINT "Hallo
MAKE "Zahl 10
Wenn der Wert einer Variablen angezeigt oder übergeben werden soll, so schreibt man vor die Variable
einen Doppelpunkt. Beispiele:
QUADRAT :Seite
PRINT :Zahl
PRINT "Zahl druckt das Wort »Zahl«
PRINT Zahl ergibt einen Fehler
Das erste Beispiel ruft die Prozedur QUADRAT auf und übergibt die Seitenlänge in der Variablen
SEITE.
Das zweite Beispiel druckt den Wert der Variablen ZAHL aus. Nach der Definition im vorigen Absatz
also eine 10.
Das dritte Beispiel ergibt nicht die Zahl 10, sondern es wird das Wort »Zahl« ausgegeben. Weil ein
Anführungszeichen davor steht, wird dieser Ausdruck nicht ausgewertet.
Im letzten Beispiel wird erst die Prozedur PRINT aufgerufen, und danach die Prozedur ZAHL. Das ergibt
einen Fehler, da eine Prozedur namens ZAHL nicht existiert (»I don't know how to Zahl«).
Wenn Sie ein Zeichen, das normalerweise eine besondere Funktion im Syntax von LOGO hat, als Literal
verwenden möchten, so können Sie dies erreichen, indem Sie einen Backslash » \ « voranstellen. Derartige
Sonderzeichen sind: Leerzeichen, runde und eckige Klammern, Infix-Operatoren, Backslash, vertikaler
Strich, Tilde, Anführungszeichen, Fragezeichen, Doppelpunkt und Semikolon. Beispiele:
print "Hans Albers
Hans
I don't know how to Albers
print "Hans\ Albers
Hans Albers
Bei MSWLogo ist es übrigens egal, ob Sie groß oder klein schreiben. Der Einfachheit halber schreibe ich
ab jetzt alles klein. Lassen Sie sich dadurch nicht verwirren.
LOGO-Tutorial
Lassen Sie uns als Einstieg in die Sprache ein paar einfache Befehle und Prozeduren erproben. Beginnen
wir mit etwas Turtlegrafik.
Zeichnen mit der Turtle
Im oberen Fenster ist die Turtle als kleines Dreieck sichtbar. Nach dem Start von MSWLogo ist die Turtle
sofort in der Lage, Linien zu ziehen. Sie können dies überprüfen:
show pen
[pendown paint [1 1] [0 0 0] [1]]
Die Ausgabe der PEN-Funktion ist eine Liste, die in diesem Falle besagt, daß der Stift abgesenkt ist
(pendown), der Zeichenmodus paint, die Strichstärke 1 und die Farbe [0 0 0] (schwarz) ist.
Nun können wir mal eine Linie zeichnen:
forward 100
Die Turtle bewegt sich 100 Einheiten vorwärts und zieht dabei eine Linie. Der Befehl FORWARD kann
auch abgekürzt werden zu FD. Nun wollen wir mal eine Drehung versuchen:
right 90
Die Turtle vollführt eine Drehung um 90° im Uhrzeigersinn. Auch der Befehl RIGHT kann abgekürzt
werden: RT. Wir wollen nun mal ein Quadrat zeichnen. Dazu geben Sie bitte nacheinander an der
Kommandozeile ein:
fd
rt
fd
rt
fd
100
90
100
90
100
Fertig ist unser Quadrat! Aber das war eigentlich ein bißchen viel Tipparbeit für eine so einfache Figur. Bei
genauem Hinsehen erkennen wir, daß die beiden Befehle FD und RT jeweils viermal verwendet wurden.
Das kann man also noch vereinfachen! Zuvor jedoch löschen wir den Bildschirm:
cs
repeat 4 [fd 100 rt 90]
Der Befehl CS ist eine Abkürzung für CLEARSCREEN. Dadurch wird der Grafikbildschirm gelöscht
und die Turtle in die Homeposition gesetzt. Der Befehl REPEAT wiederholt die Anweisungen zwischen
den eckigen Klammern (der »Anweisungsliste«), und zwar so oft, wie das erste Argument angibt. In
diesem Falle viermal.
Prozeduren definieren
Wir können noch weiter vereinfachen, indem wir uns eine Prozedur namens QUADRAT machen. Dann
können wir ein Quadrat zeichnen durch die Eingabe eines einzigen Befehls. Dazu rufen wir zunächst den
Editor auf:
edit "quadrat
Darauf öffnet sich das Fenster des Editors. Die erste (mit TO beginnende) und die letzte (mit END
gefüllte) Zeile der Prozedur stehen bereits dort. Sie müssen nur noch ergänzen:
to quadrat
repeat 4 [fd 100 rt 90]
end
Zum Verlassen des Editors wählen Sie im Menü »File/Save and Exit«. Prüfen Sie kurz, ob die Prozedur
nun definiert ist: Geben Sie POTS ein. Der Name der Prozedur sollte auftauchen. Testen sie Ihre Prozedur.
Geben Sie ein:
quadrat
Die Turtle zeichnet ein Quadrat mit der Seitenlänge 100.
Wir wollen nun die Prozedur so ändern, daß die Seitenlänge des Quadrates beim Aufruf der Prozedur als
Parameter angegeben werden kann. Dazu rufen wir zuerst mal den Editor auf:
ed "quadrat
Hier habe ich statt EDIT die Abkürzung ED verwendet. Nun müssen wir im Titel der Prozedur einen
formalen Parameter angeben, der die Seitenlänge aufnehemen soll. In der Prozedur selbst muß an der
geeigneten Stelle eine Variable stehen, die den aktuellen Wert der Seitenlänge hat. Ändern Sie also die
Prozedur wie folgt:
to quadrat :seite
repeat 4 [fd :seite rt 90]
end
Beenden Sie den Editor mit »File/Save and Exit«. Geben Sie im Commander ein:
quadrat 50
quadrat 100
ht
Die Turtle zeichnet zwei Quadrate mit den Seitenlängen 50 und 100. Mit dem letzten Befehl HT (Hide
Turtle) wird die Turtle unsichtbar gemacht und wir können unser Werk bewundern.
Die Parameterübergabe erfolgt übrigens »by value«, d.h. die Variable SEITE ist nur innerhalb der
Prozedur QUADRAT gültig.
Wir wollen jetzt unsere Prozedur noch ein wenig erweitern, so daß sie beliebige Polygone mit beliebiger
Seitenlänge zeichnen kann. Dazu wäre es auch sinnvoll, ihr einem anderen Namen zu geben, z.B.
POLYGON. Dafür rufen wir nun wieder den Editor auf:
ed "quadrat
to polygon :seite :zahl
repeat :zahl [fd :seite rt 360/ :zahl]
end
Nachdem wir den Namen der Prozedur im Editor geändert haben (durch Ändern der Titelzeile), existiert
die ursprüngliche Prozedur QUADRAT nicht mehr, wenn wir den Editor verlassen. Testen Sie die neue
Prozedur POLYGON:
polygon 150 3
polygon 100 6
Der erste Befehl zeichnet ein Dreieck mit der Seitenlänge von 150 Einheiten, der zweite zeichnet ein
Sechseck mit der Seitenlänge von 100 darüber. Nach der Eingabe von HT (Hide Turtle) verschwindet die
Turtle vom Bildschirm. Ein ST (Show Turtle) bringt sie wieder hervor. Diese Kommandos können Sie
natürlich auch in die Prozedur schreiben.
Objekte manipulieren
Worte und Listen sind die »Datentypen« von LOGO, Zahlen sind ein Sonderfall der Worte. Bei der Liste
handelt sich um eine verkettete Liste ähnlich den Listen in LISP. Auch die Prozeduren selbst werden in
Listen gespeichert. Somit können wir Programme schreiben, die andere Programme beeinflussen. Alle
diese LOGO-Objekte können auf vielfältige Weise manipuliert werden.
make "Fluss "Alster
Mit diesem Befehl definieren wir eine Variable mit dem Namen FLUSS und weisen ihr den Wert »Alster«
zu. Wir können uns alle Variablen im Speicher jederzeit ansehen mit dem Befehl PONS (Print Out
Names), der alle definierten Namen auflistet:
pons
Ein Wort läßt sich zerlegen in einzelne Zeichen. LOGO bietet dazu die Funktionen FIRST, LAST,
BUTFIRST (BF) und BUTLAST (BL) an. Die Abkürzungen zu den Funktionen stehen in Klammern
dahinter.
Spielen wir einmal mit unserem FLUSS ein wenig herum:
print first :Fluss
A
Die Funktion FIRST liefert das erste Element des übergebenen Objektes zurück. Wenn das Objekt ein
Wort ist, liefert sie das erste Zeichen. Die Funktion PRINT gibt das Zeichen aus. Beachten Sie den
Doppelpunkt vor FLUSS. Er zeigt LOGO an, daß wir den Inhalt der Variablen haben möchten. Was
geschähe, wenn wir den Doppelpunkt wegließen? Was wäre, wenn statt des Doppelpunktes ein
Anführungszeichen dort stünde?
PRINT läßt sich abkürzen mit PR. Analog zu FIRST liefert LAST das letzte Element:
pr last :Fluss
r
Die Funktion BUTFIRST (BF) liefert alles bis auf das erste Element zurück:
pr bf :Fluss
lster
Die Funktion BUTLAST (BL) liefert alles bis auf das letzte Element zurück:
pr bl :Fluss
Alste
Wir wollen nun eine Variable erzeugen, die eine Liste enthält. Danach werden wir die Funktionen FIRST,
LAST, BUTFIRST und BUTLAST auf diese Liste anwenden.
make "Stadt [Hamburg liegt an der Elbe]
pr first :Stadt
Hamburg
pr last :Stadt
Elbe
pr item 2 :Stadt
liegt
show bf :Stadt
[liegt an der Elbe]
show bl :Stadt
[Hamburg liegt an der]
Bei den beiden letzten Beispielen habe ich statt des PRINT-Befehles den Befehl SHOW angewendet. Der
Grund hierfür ist, das PRINT bei einer Liste nicht die eckigen Klammern anzeigt. BUTFIRST und
BUTLAST geben nämlich eine Liste zurück, wenn das übergebene Objekt eine Liste war. FIRST und
LAST geben in diesem Falle ein Wort zurück.
Das dritte Beispiel zeigt, wie mit Hilfe der Funktion ITEM ein beliebiges Element aus einer Liste selektiert
werden kann.
Bislang haben wir LOGO-Objekte nur »zerlegt«. Dieses Zerlegen wirkt sich jedoch nicht destruktiv auf die
Originalobjekte aus. Die LOGO-Hilfe bezeichnet diese Funktionen daher auch als »Selektoren« (echte
Veränderungen an den Originalobjekten bewirken die »Mutatoren«).
Nun wollen wir einige »Konstruktoren« erproben. Diese lassen ebenso wie die Selektoren die
Originalobjekte intakt. Die wichtigsten Konstruktoren sind WORD, SENTENCE (SE), LIST, FPUT
und LPUT.
show word "a "b
ab
show (word "a "b "c)
abc
show word "all "gemein
allgemein
WORD liefert ein Wort zurück, das aus seinen Eingaben besteht. Die Eingaben können selbst Worte sein
wie im dritten Beispiel. Im zweiten Beispiel ist um die gesamte Funktion WORD mit ihren Eingaben eine
runde Klammer gesetzt, weil WORD als Standard nur zwei Parameter erwartet. Durch die Klammern
wird angezeigt, daß die folgenden drei Parameter als Eingang von WORD dienen sollen. Diese runden
Klammern finden Sie in LOGO immer, wenn eine Funktion mehr Eingaben als der Standard bekommen
soll.
show se "Hamburger [Wetter ist kalt]
[Hamburger Wetter ist kalt]
show list "Hamburger [Wetter ist kalt]
[Hamburger [Wetter ist kalt]]
Diese beiden Beispiele zeigen das unterschiedliche Verhalten von SENTENCE und LIST. Beide nehmen
als Eingaben Worte und Listen an. SENTENCE (SE) packt alle seine Eingaben in eine Liste, egal ob
Worte oder Listen. LIST dagegen gibt eine Liste zurück, die aus den Eingabe-Elementen besteht.
make "Fisch [Forellen sind flink]
show lput "gegessen :fisch
[Forellen sind flink gegessen]
show fput "Alle :fisch
[Alle Forellen sind flink]
An diesen Beispielen wird die Wirkung der Funktionen LPUT und FPUT gezeigt. LPUT fügt ein Objekt
am Ende einer Liste an, FPUT tut das gleiche am Anfang. Der zweite Parameter dieser Funktionen muß
eine Liste sein.
Eingangs erwähnte ich, daß auch Prozeduren als Listen gespeichert werden. Sie können sich die Listenform
einer Prozedur ansehen mit der Funktion TEXT. Nehmen wir z.B. die Prozedur POLYGON aus einem
Abschnitt weiter oben. Die von TEXT gelieferte Liste lassen Sie sich mit SHOW anzeigen:
show text "polygon
[[seite zahl] [repeat :zahl [fd :seite rt 360 / :zahl]]]
Die von TEXT gelieferten Listen können wir wieder als Eingang für DEFINE verwenden, mit der sich
Prozeduren im Listenformat definieren lassen. Auf diese Weise können wir eine Kopie von POLYGON
mit dem Namen VIELECK erzeugen:
define "vieleck text "polygon
Rekursive Prozeduren
Die LOGO-Datentypen Wort und Liste sind so aufgebaut, daß sie mit rekursiven Algorithmen bearbeitet
werden können. Daher ist es nur folgerichtig, wenn wir solche Daten mit rekursiven Prozeduren bearbeiten.
Rekursive Prozeduren rufen sich selbst auf. Damit es nicht zu einer endlosen Schleife kommt, muß eine
Abbruchbedingung formuliert werden. Der Abbruch erfolg dann mit den Befehlen STOP oder OUTPUT
(OP).
Es soll nun eine Prozedur entwickelt werden, die alle Elemte einer eingegebenen Liste vertikal ausdruckt.
Die Prozedur soll VERTIKAL heißen, und sie hat einen Parameter namens :SATZ.
to vertikal :satz
if :satz = [][stop]
pr first :satz
vertikal bf :satz
end
Der Prozedur wird die zu druckende Liste im Parameter :SATZ übergeben. Die dritte Zeile druckt das
erste Element der Liste. In der vierten Zeile erfolgt der rekursive Aufruf: VERTIKAL ruft sich selbst auf
und übergibt eine um das erste Element gekürzte Liste. Dies geschieht durch die Befehle BF :SATZ.
Entscheidend ist die zweite Zeile: Hier wird getestet, ob die übergebene Liste leer ist. Wenn das der Fall
ist, so soll die aktuelle Prozedur abgebrochen werden. Die Programmausführung springt zur nächst höheren
Ebene zurück. Dort landet sie auf der Zeile hinter dem Selbstaufruf (END). Auch diese Prozedur wird
beendet. Das geht so weiter bis zur höchsten Ebene. Wir wollen unsere Prozedur einmal testen:
vertikal [gestern heute morgen]
gestern
heute
morgen
Wenn Sie einmal sehen wollen, welche Listen denn auf den jeweiligen Ebenen der Prozedur übergeben
werden, so können Sie eine zusätzliche Zeile in die Prozedur einfügen, die die aktuelle Liste ausdruckt:
to vertikal :satz
(show "übergeben "wurde: :satz)
if :satz = [][stop]
pr first :satz
vertikal bf :satz
end
Wenn Sie nun die Prozedur starten, sehen Sie vor jedem Ausdruck die übergebene Liste:
vertikal [gestern heute morgen]
übergeben wurde: [gestern heute morgen]
gestern
übergeben wurde: [heute morgen]
heute
übergeben wurde: [morgen]
morgen
übergeben wurde: []
Wenn wir Prozeduren schreiben wollen, die einen Wert zurück liefern wie eine echte Funktion, so müssen
wir die Funktion OUTPUT verwenden. Sie sorgt für die Rückgabe eines Funktionswertes und dient in
rekursiven Prozeduren zum Abbruch ähnlich wie STOP.
Nun ein etwas schwierigeres Beispiel mit der Funktion OUTPUT (OP). Die Funktion, die wir entwerfen
wollen, soll ein eingegebenes Wort rückwärts ausgeben, aber nicht direkt drucken (so wie vorhin
VERTIKAL). Sie soll RETOUR heißen.
Unsere Funktion muß zunächst das letzte Zeichen eines Wortes ausgeben und danach sich selbst aufrufen.
Dabei muß das um das letzte Zeichen verkürzte Wort übergeben werden:
output last :wort retour butlast :wort
OUTPUT LAST :WORT liefert hier den letzten Buchstaben, der Aufruf von RETOUR mit BUTLAST
:WORT in dieser Zeile liefert den Rest. Die beiden Teile müssen nur noch mit WORD verbunden werden:
output word last :wort retour butlast :wort
Außerdem muß noch eine Abbruchbedingung für die Rekursion formuliert werden. Die Abbruchbedingung
ist das leere Wort, in diesem Falle soll RETOUR ein leeres Zeichen (also »nichts«) liefern:
if emptyp :wort [op " ]
Die komplette Prozedur sieht so aus:
to retour :wort
if emptyp :wort [op " ]
op word last :wort retour bl :wort
end
Ein kurzer Test unserer neuen Funktion:
pr retour "abcde
edcba
Zum Schluß dieses Abschnittes noch ein kleines Grafik-Programm. Es besteht aus den zwei Prozeduren
BAUM und BAUM1. Die erste dient nur zur Vorbereitung: die Stiftgröße und -Farbe wird eingestellt, der
Ausgangspunkt der Turtle etc. Dann wird die Prozedur BAUM1 aufgerufen. Sie ist stark rekursiv!
Die Abbruchbedingung wird mit einer Zähler-Variablen N realisiert. Innerhalb von BAUM1 ruft die
Prozedur sich zweimal selbst auf. Jedesmal wird eine um eins verminderte Variable übergeben. Der
Abbruch ist erreicht, wenn :N = 0. In BAUM1 wird die Turtle vorwärts und rückwärts bewegt in
Abhängigkeit von N. Außerdem wird die Stiftfarbe in Abhängigkeit von N geändert.
Ich stelle hier einmal das Programm BAUM ohne weitere Kommentare vor. Versuchen Sie einmal, was
passiert, wenn Sie in der Prozedur BAUM in der vorletzten Zeile den Parameter hinter BAUM1
verändern, z.B. wenn Sie 6 statt 8 schreiben.
TO BAUM
CS HT
SETPENSIZE [10 10]
SETPENCOLOR [100 0 0]
PU SETPOS [0 -180]
PD FD 60
BAUM1 8
END
TO BAUM1 :N
IF :N = 0 [STOP]
SETPENCOLOR (LIST 100 (240 - :N * 30) 0)
LT 25 FD 10 * :N
BAUM1 :N - 1
SETPENCOLOR (LIST 100 (240 - :N * 30) 0)
BK 10 * :N RT 25
RT 25 FD 10 * :N
BAUM1 :N - 1
SETPENCOLOR (LIST 100 (240 - :N * 30) 0)
BK 10 * :N LT 25
END
Speichern und Laden
Wenn Sie eine Anzahl Prozeduren geschrieben haben, werden Sie sie irgendwann speichern wollen. Bei
MSWLogo gibt es zwei Methoden, um dies zu erreichen:
1. Sie gehen über das FILE-Menü
2. Sie benutzen die Kommandozeile
Das Menü ist sicher für den Anfänger am einfachsten. Wie von anderen Programmen gewohnt können Sie
über die Menüpunkte »File/Save As« alle im Arebitsspeicher definierten Namen und Prozeduren in eine
Datei schreiben, und mit »File/Load« können Sie den Inhalt einer Datei in den Arbeitsspeicher lesen und
ausführen. Es ist wichtig, daran zu denken, daß die Datei nicht einfach nur in den Arbeitsspeicher kopiert
wird, sondern Zeile für Zeile ausgeführt wird, so als kämen die Eingaben von der Tastatur.
Wenn ein Objekt mit dem Namen STARTUP existiert, so wird die Liste mit diesem Namen sofort nach
dem Laden der Datei ausführt. Auf diese Weise können Sie automatisch startende LOGO-Programme
schreiben.
Beim Speichern werden alle Namen und Prozeduren in eine Datei geschrieben. Die Vorgabe für die
Endung ist .LGO für LOGO-Dateien. Es werden jedoch nur die Namen und Prozeduren geschrieben, die
nicht »verborgen« (BURIED) sind (siehe weiter unten).
Zum Laden einer Datei dient das Kommando LOAD, gefolgt von dem Dateinamen. Das Verzeichnis, in
dem sich die Datei befindet, muß das aktuelle Verzeichnis sein. Zum Navigieren in den Verzeichnissen
dienen die Befehle DIR, CHDIR und POPDIR.
load "baum.lgo
Beachten Sie bitte, daß beim Einlesen der Prozeduren und Namen aus einer Datei die neuen Namen und
Prozeduren denen hinzugefügt werden, die bereits im Arbeitsspeicher bestehen. Objekte mit gleichem
Namen wie bereits bestehende überschreiben diese.
Das »Verbergen« dient der Verwaltung des Arbeitsspeichers. Alle Namen, Prozeduren und
Eigenschaftslisten mit dem Attribut »buried« werden von POTS und PONS nicht angezeigt und durch
SAVE nicht gespeichert.
Der Befehl BURY erwartet eine Liste mit drei Teillisten mit den Namen der Prozeduren, Variablen und
Eigenschaftslisten, die zu verbergen sind.
pots
TO BAUM
TO BAUM1 :N
bury [[baum] [] []]
pots
TO BAUM1 :N
Nun kann der Teil der Prozeduren, die nicht verborgen sind, in eine neue Datei geschrieben werden:
save "baumteil.lgo
baumteil.lgo
Schließlich können wir die verborgene Prozedur wieder »ausgraben«:
unbury [[baum] [] []]
pots
TO BAUM
TO BAUM1 :N
Ende
Dies war nur ein kurzer Einstieg in LOGO. Vieles habe ich nur ganz kurz gestreift. Es sollte jedoch
ausreichen, daß Sie sich mit Hilfe der Online-Dokumentation und etwas Mut zum Experimentieren in die
Sprache einarbeiten können. Viel Spaß mit dieser ungewöhnlichen Programmiersprache!
Günther Schättiger
[email protected]