Einstieg in LOGO

von Günther Schättiger, Juni 1999
Ergänzungen/Änderungen, Februar 2003

Inhalt

Einleitung
Struktur eines LOGO-Programmes
Primitive
Prozeduren
LOGO-Objekte
Turtle-Grafik
Anmerkungen zur Syntax
LOGO-Tutorial
Zeichnen mit der Turtle
Prozeduren definieren
Objekte manipulieren
Rekursive Prozeduren
Speichern und Laden
Ende

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 LOGO-Programme nicht unter englischsprachigen Interpretern laufen.

Bezugsquellen

Die hier beschriebenen Programme laufen unter MSW-Logo von Softronix und UCB-Logo von Brian Harvey. Beide gibt es kostenlos.

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:

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 LISP-Programmierer. 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 100
rt 90
fd 100
rt 90
fd 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 Arbeitsspeicher 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
schaetti@informatik.uni-hamburg.de