Logo: Meta: Überblick

Logo: Meta

Logo

In den 60er Jahren hat Seymour Papert die Programmiersprache Logo entwickelt. Als Vorbild diente dabei die Programmiersprache Lisp.

Logo ist eine Interpretersprache, die in einer Umgebung abläuft. Das bedeutet, daß man eine Funktion definieren kann, und solange man die Umgebung nicht beendet, kann man diese Funktion verwenden.

Der Sprung in das kalte Wasser

Logo

Die Software

Sie möchten Logo lernen und Programme in Logo schreiben. Dazu besorgen Sie sich am besten eine Logo-Software. Im Internet kann man sich kostenlos die gewünschte Software herunterladen. Zwischen den einzelnen Produkten mag es Unterschiede geben, darum wird hier UCB Logo verwendet, das, abgesehen von einer Unzahl an erweiterten Befehlen, sich wie Standard-Logo verhält.

Download Links siehe Logo: Quellen#Logo-Versionen

Starten der Umgebung

Sie haben sich die Software besorgt und auf dem Computer installiert? Schön, dann kann man sich mit der Umgebung vertraut machen. Starten Sie die Software und gehen Sie in den Vollbildmodus. Sie sehen eine weiße Fläche (kann auch schwarz sein), oben steht eine Statusmeldung und darunter ein Fragezeichen. Das Fragezeichen fordert Sie dazu auf, eine Eingabe zu machen. Geben Sie zum Beispiel Print "Hallo ein und bestätigen Sie mit Enter. Dann sollte Folgendes zu sehen sein:

? print "Hallo
Hallo
?

Probieren Sie es mit Print "Hallo Welt. Dann kommt eine Fehlermeldung:

? print "Hallo Welt
Hallo
I don't know to Welt
?

Der Interpreter sieht Welt als Anweisung an. Da die Anweisung Welt aber nicht existiert, kann er nichts damit anfangen. Schreiben Sie stattdessen Print [Hallo Welt]

? print [Hallo Welt]
Hallo Welt
?

Der Interpreter hat in diesem Fall die beiden Objekte aus Liste [Hallo Welt] ausgegeben. Er hat dabei nicht versucht, die beiden Objekte zu interpretieren.

Man kann die Liste auch auf eine Variable legen:

? make "gruss [Hallo Welt]
? print gruss
Hallo Welt
?

Erstellen Sie jetzt ein kleines Programm, eine Prozedur:

? to hallo
> print [Hallo Welt]
> end
?

Mit dem Aufruf hallo wird die Prozedur gestartet:

? hallo
Hallo Welt
?

Machen sie mal etwas mit der Turtlegraphics. Erstellen Sie eine Prozedur, die eine geometrische Darstellung erstellt:

? to triangle
> fd 80 rt 120 fd 20 rt 120
> fd 80 rt 120 fd 20 rt 120
> fd 80 rt 120 fd 20 rt 120
> end

Mit dem Aufruf Triangle wird ein gleichseitiges Dreieck gezeichnet, an dem drei kleinere gleichseitige Dreiecke hängen. Man hätte die Prozedur auch kürzer schreiben können, und man hätte der Prozedur einen Parameter mitgeben können, mit dem man die Größe des gezeichneten Objekts hätte beeinflussen können. Gehen Sie jetzt mit textscreen wieder in den Textmodus.

Da Sie zwei Prozeduren geschrieben haben, sind sie im Speicher abrufbar. Mit poall werden alle während der Sitzung erstellte, oder dazugeladenen Prozeduren, Funktionen und Variablen angezeigt:

? Poall
to hallo
print [Hallo Welt]
end

to triangle
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
end

make "gruss [Hallo Welt]

?

Möchte man nur die Prozeduren und Funktionen angezeigt bekommen, nicht aber die Variablen, dann gibt es die Anweisung pops:

? pops
to hallo
print [Hallo Welt]
end

to triangle
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
end

?

Mit pots bekommt man nur die Prozedurköpfe:

? pots
to hallo
to triangle

?

Möchte man nur die Variablen sehen, dann benutzt man pons:

? pons
make "gruss [Hallo Welt]

?

Sobald man die Umgebung beendet, werden alle bisher erstellten Prozeduren und Variablen zerstört. Mit save "dateiname lassen sich die Prozeduren und Variablen speichern:

? save "erste_sitzung
?

Nun kann man mit erall den gesamten Speicher löschen. Die Prozeduren und Variablen sind verschwunden:

? erall
? poall
?

Mir load "dateiname kann man das gespeicherte wieder in die Sitzung laden:

? load "erste_sitzung
? poall
to hallo
print [Hallo Welt]
end

to triangle
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
end

make "gruss [Hallo Welt]

?

Mit bye können Sie die Sitzung beenden.

Konstrukte

Logo

Zuweisungen werden mit make realisiert

make "index 1

Initialisierung einer leeren Liste

make "buecher []

Schleife

repeat Anzahl der wiederholungen [ Anweisungsfolge ]

Ausgabe

print

selbstdefinierte Prozeduren und Funktionen

Logo

Prozedur

Die Funktion ist ein wichtiger Bestandteil der Programmiersprache Logo. Man kann natürlich unter Logo jede Anweisung einzeln ausführen, aber das wird umständlich. Am Beispiel zur Darstellung eines Sechsecks lässt sich das deutlich zeigen:

"Zu Fuß" muss man folgende Anweisungen eingeben:

fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60

Als Funktion definiert sieht das Ganze dann so aus:

to sechseck
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
end

Um das Sechseck darzustellen muss man nur noch das eingeben:

sechseck

Das ganze hat aber noch mehrere Nachteile:

1. Es ist zu lang
2. Es ist zu starr
3. Es ist zu unflexibel

Statt

to sechseck
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
end

lässt sich auch

to sechseck
repeat 6 [ fd 40 rt 60 ]
end

schreiben

Man kann eine variable Seitenlänge einfügen:

to sechseck :laenge
repeat 6 [ fd :laenge rt 60 ]
end

Man kann eine variable Eckenanzahl einfügen, so das auch andere regelmäßige Polyeder dargestellt werden können:

to polyeder :ecken :laenge
repeat :ecken [ fd :laenge rt 360 / :ecken ]
end

Turtle-Grafik

Logo

Das Prinzip der grafischen Darstellung unter der Programmiersprache Logo unterscheidet sich grundsätzlich erstmal von der anderer Programmiersprachen, die mit Koordinaten arbeiten. In Logo hat man eine virtuelle Schildkröte (engl. turtle), die einen Stift hinter sich herzieht und so bei Bedarf einen farbigen Strich zeichnet. Es gilt, diese Schilkröte mit gezielten Anweisungen fernzusteuern. Dies geht mit den nachfolgenden Anweisungen:

• Um Grafik darstellen zu können, sollte man in den Grafikmodus gehen. Das geht mit fullscreen oder auch kurz fs.

forward länge fd länge Die Schildkröte bewegt sich um eine bestimmte Anzahl von Einheiten nach vorne

back länge  bk länge Die Schildkröte bewegt sich um eine bestimmte Anzahl von Einheiten zurück

right winkel rt winkel Die Schildkröte dreht sich um einen bestimmten Winkel nach rechts

left winkel lt winkel Die Schildkröte dreht sich um einen bestimmten Winkel nach links

setpencolor farbewert setpc farbwert Der Schildkröte wird eine Zeichenfarbe zugewiesen

pendown  pd  Der Stift wird auf die Zeichenfläche gesetzt

penup pu  Der Stift wird von der Zeichenfläche genommen

textscreen || ts || Text-Modus
home ||    Die Schildkröte bewegt sich zur Mitte des Bildschirms mit Ausrichtung nach oben (0°)
clean ||  Der Bildschirm wird gelöscht, die Position der Schildkröte ändert sich nicht
cleanscreen || cs || home und clean zusammen
hideturtle || ht || Die Schildkröte wird unsichtbar
showturtle || st || Die Schildkröte wird sichtbar

Grafik mit Koordinaten

Es gibt aber auch in der Programmiersprache Logo die Möglichkeit, koordinatenbezogene Grafik zu erzeugen. Die geht mit der Anweisung setpos [x y]

Setpos [x y] setzt die Schildkröte genau an die Koordinaten, die in der Liste [x y] stehen. Zwischen dem Punkt, wo die Schildkröte vor Ausführung des Setpos war, und der neuen Koordinate hat die Schildkröte einen Strich gezeichnet. Um das gezielt unter Kontrolle zu halten, kann man sich der Anweisungen pu und pd bedienen.

Eine Anweisung Linie :x1 :y1 :x2 :y2 :farbwert würde so aussehen:

to linie :x1 :y1 :x2 :y2 :farbwert
make "koo1 []
make "koo2 []
make "koo1 lput :x1 :koo1
make "koo1 lput :y1 :koo1
make "koo2 lput :x2 :koo2
make "koo2 lput :y2 :koo2
setpc :farbwert
pu
setpos :koo1
pd
setpos :koo2
pu
end

Eine Anweisung box :x1 :y1 :x2 :y2 :farbwert entsprechend so:

to box :x1 :y1 :x2 :y2 :farbwert
make "koo1 []
make "koo2 []
make "koo3 []
make "koo4 []
make "koo1 lput :x1 :koo1
make "koo1 lput :y1 :koo1
make "koo2 lput :x1 :koo2
make "koo2 lput :y2 :koo2
make "koo3 lput :x2 :koo3
make "koo3 lput :y2 :koo3
make "koo4 lput :x2 :koo2
make "koo4 lput :y1 :koo2
setpc :farbwert
pu
setpos :koo1
pd
setpos :koo2
setpos :koo3
setpos :koo4
setpos :koo1
pu
end

Listen

Logo

Neben der Turtle-Grafik spielen die Listen in Logo eine gewisse Rolle, zumal Lisp der Pate für Logo ist.

Was ist eine Liste?

In Logo ist eine Liste ein Konstrukt, bei der Elemente innerhalb einer eckigen Klammer stehen. Beispiel für Listen:

[ rot gelb gruen cyan blau magenta ]
[ Dies ist ein Satz in einer Liste]
[ 1 3 6 10 15 21 ]

Eine Liste kann wiederum auch Listen enthalten:

[ [ Brot Butter ] [ Milch Kase ] ]

Eine Liste kann auch leer sein:

[]

Überhaupt hat eine Liste viel Ähnlichkeit mit einer Menge.

Wie bekommt man Elemente in eine Liste?

Man kann eine Liste schon vordefinieren:

MAKE "Wochentage [Montag Dienstag Mittwoch Donnerstag Freitag]

Man kann auch ein Element in eine Liste hinzufügen:

MAKE "Tiere LPUT Katze :Tiere

Wenn die Liste Tiere vorher so aussah: [Hund Meerschweinchen Schildkröte], dann enthält sie danach: [Hund Meerschweinchen Schildkröte Katze].

Wie läßt sich feststellen, ob ein Element in einer Liste enthalten ist?

Das läßt sich mit der logischen Funktion MEMBERP Element Liste erreichen.

Sieb des Erastothenes

Als Beispiel für ein Programm mit Listen soll das Sieb des Eratothenes dienen. Das Sieb des Eratosthenes ermittelt aus einem Intervall der natürlichen Zahlen, von 2 bis zu einer fest vorgegebenen Obergrenze, alle Primzahlen durch heraussieben. Normalerweise wird so etwas mit einem Array realisiert. Man gibt vor, alle Zahlen von 2 bis zur Obergrenze seien Primzahlen, und entfernt dann alle Vielfachen von einer Primzahl angefangen mit der 2.

Da es keine Arrays in Logo gibt, muss man das Ganze etwas anders realisieren. Man nimmt zwei Listen, nämlich P (liste aller Primzahlen) und NP (Liste aller Nichtprimzahlen). Die Liste der Nichtprimzahlen ist hier besonders wichtig. Beide Listen sind zu Beginn leer. Wie wird nun vorgegangen? Genau umgekehrt; man geht davon aus, alle Zahlen seien keine Primzahl. Man beginnt mit der 2, und schaut nach, ob 2 in NP einthalten ist. Das ist nicht der Fall, also ist 2 eine Primzahl. Also wird 2 zur Liste P hinzugefügt, und alle Vielfachen von 2, bis zu einer gewissen Grenze, NP hinzugefügt. Danach kommt der nächste Primzahlkandidat.

TO PRIMZAHL :OBERGRENZE
MAKE "WERT 1
REPEAT :OBERGRENZE  MAKE "WERT :WERT + 1 IF NOT MEMBERP :WERT :NP  PRINT :WERT UNTERPRIM :OBERGRENZE :WERT
END

TO UNTERPRIM :OBERGRENZE :WERT
MAKE "ADDER :WERT
MAKE "P LPUT :WERT :P
REPEAT :OBERGRENZE / :WERT  MAKE "ADDER :ADDER + :WERT UNTERUNTERPRIM :ADDER :WERT
END

TO UNTERUNTERPRIM :ADDER :WERT
MAKE "NP LPUT :ADDER :NP
END

TO LOESCHEN
MAKE "P
MAKE "NP  1
END

Beispiele

Logo

Turtle-Grafik

• mn_eck

to n_eck :ecken :laenge
repeat :seiten [rt 360 / :ecken fd :laenge]
end

to mn_eck :ecken :laenge
repeat :ecken [rt 360 / :ecken n_eck :ecken :laenge]
end

• Zufallslinien

to line
make "ll1 []
make "ll2 []
make "x1 ((random 400) - 200)
make "y1 ((random 400) - 200)
make "x2 ((random 400) - 200)
make "y2 ((random 400) - 200)
make "ll1 lput :x1 :ll1
make "ll1 lput :y1 :ll1
make "ll2 lput :x2 :ll2
make "ll2 lput :y2 :ll2
make "colr random 8
setpc :colr
pu
setpos :ll1
pd
setpos :ll2
end

to lines
repeat 512 [line]
end

Fraktale

• Kock-Kurve und kochsche Schneeflocke

Kochsche Schneeflocke

to kurve :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 3
if :stufe > 0 [kurve :stufe :laenge rt 60 kurve :stufe :laenge lt 120 kurve :stufe :laenge rt 60 kurve :stufe :laenge]
if :stufe = 0 [fd :laenge rt 60 fd :laenge lt 120 fd :laenge rt 60 fd :laenge]
end

to flocke :stufe :laenge
repeat 3 [kurve :stufe :laenge lt 120]
end

• Drachenkurve

Drachenkurve

to dragon :stufe :laenge
dcr :stufe :laenge
end

to dcr :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 1.41421
if :stufe > 0 [rt 45 dcr :stufe :laenge lt 90 dcl :stufe :laenge rt 45]
if :stufe = 0 [rt 45 fd :laenge lt 90 fd :laenge rt 45]
end

to dcl :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 1.41421
if :stufe > 0 [lt 45 dcr :stufe :laenge rt 90 dcl :stufe :laenge lt 45]
if :stufe = 0 [lt 45 fd :laenge rt 90 fd :laenge lt 45]
end

• Gosperkurve

Gosper-Kurve

to rg :st :ln
make "st :st - 1
make "ln :ln / 2.6457
if :st > 0 [rg :st :ln rt 60 gl :st :ln  rt 120 gl :st :ln lt 60 rg :st :ln lt 120 rg :st :ln rg :st :ln lt 60 gl :st :ln rt 60]
if :st = 0 [fd :ln rt 60 fd :ln rt 120 fd :ln lt 60 fd :ln lt 120 fd :ln fd :ln lt 60 fd :ln rt 60]
end

to gl :st :ln
make "st :st - 1
make "ln :ln / 2.6457
if :st > 0 [lt 60 rg :st :ln rt 60 gl :st :ln gl :st :ln rt 120 gl :st :ln rt 60 rg :st :ln lt 120 rg :st :ln lt 60 gl :st :ln]
if :st = 0 [lt 60 fd :ln rt 60 fd :ln fd :ln rt 120 fd :ln rt 60 fd :ln lt 120 fd :ln lt 60 fd :ln]
end

• Pfeilspitze

to pfeilspitze :stufe :laenge
rpfeil :stufe :laenge
end

to rpfeil :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 2
if :stufe > 0 [rt 60 lpfeil :stufe :laenge lt 60 rpfeil :stufe :laenge lt 60 lpfeil :stufe :laenge rt 60]
if :stufe = 0 [rt 60 fd :laenge lt 60 fd :laenge lt 60 fd :laenge rt 60]
end

to lpfeil :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 2
if :stufe > 0 [lt 60 rpfeil :stufe :laenge rt 60 lpfeil :stufe :laenge rt 60 rpfeil :stufe :laenge lt 60]
if :stufe = 0 [lt 60 fd :laenge rt 60 fd :laenge rt 60 fd :laenge lt 60]
end

• Pentaplexity

Penta Plexity

to pepl :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 2.618
if :stufe > 0 [pepl :stufe :laenge rt 72 pepl :stufe :laenge rt 72 pepl :stufe :laenge rt 180 pepl :stufe :laenge lt 36 pepl :stufe :laenge rt 72 pepl :stufe :laenge]
if :stufe = 0 [fd :laenge rt 72 fd :laenge rt 72 fd :laenge rt 180 fd :laenge lt 36 fd :laenge rt 72 fd :laenge]
end

to pp :stufe :laenge
repeat 4 [pepl :stufe :laenge rt 72]
pepl :stufe :laenge
end

Befehlsumfang

Logo

Systembefehle

Systembefehle
Befehl	Wirkung
poall	Auflisten aller Prozeduren und Variablen
pops	Auflisten aller Prozeduren
pots	Auflisten aller Prozedurenköpfe
pons	Auflisten aller Variablen
save "dateiname
load "dateiname
erall	Löschen des Speichers
erps	Löschen aller Prozeduren
erns	Löschen aller Variablen
bye	Beenden der Logo-Sitzung

Turtle-Graphics

Die wichtigsten Turtlegraphics-Befehle in LOGO
Befehl	Kurzform	Beschreibung
textscreen	ts	Text-Modus
fullscreen	fs	Graphik-Modus
home		Die Schildkröte bewegt sich zur Mitte des Bildschirms mit Ausrichtung nach oben (0°)
clean		Der Bildschirm wird gelöscht, die Position der Schildkröte ändert sich nicht
cleanscreen	cs	home und clean zusammen
hideturtle	ht	Die Schildkröte wird unsichtbar
showturtle	st	Die Schildkröte wird sichtbar
setpencolor farbewert	setpc farbwert	Der Schildkröte wird eine Zeichenfarbe zugewiesen
setbackground farbwert	setbg farbwert	Dem Hintergrund wird eine Zeichenfarbe zugewiesen
penup	pu	Der Stift wird von der Zeichenfläche genommen
pendown	pd	Der Stift wird auf die Zeichenfläche gesetzt
right winkel	rt winkel	Die Schildkröte dreht sich um einen bestimmten Winkel nach Rechts
left winkel	lt winkel	Die Schildkröte dreht sich um einen bestimmten Winkel nach Links
forward länge	fd länge	Die Schildkröte bewegt sich um eine bestimmte Anzahl von Einheiten nach vorne
back länge	bk länge	Die Schildkröte bewegt sich um eine bestimmte Anzahl von Einheiten zurück

Listen

Befehle die Listen betreffen
Befehl	Kurzform	Beschreibung
first liste		liefert das erste Element, das in der Liste enthalten ist
last liste		liefert das letzte Element, das in der Liste enthalten ist
butfirst liste	bf liste	liefert alles was in der Liste enthalten ist ohne das erste Element
butlast liste	bl liste	liefert alles was in der Liste enthalten ist ohne das letzte Element
fput element liste		fput fügt ein Element an die erste Stelle in der Liste ein
lput element liste		lput fügt ein Element an die letzte Stelle in der Liste ein
memberp element liste		logische Funktion, die ermittelt, ob element in liste enthalten ist
count liste		liefert die Anzahl der in liste enthaltenen Elemente zurück

Quellen

Logo

Logo-Versionen

UCB Logo (Windows, Linux)
ACSLogo For Mac OS X (Mac 10.4 PPC, läuft auf 10.5 Intel )

Literatur

• Programieren mit Logo, Dietrich Senftleben, ISBN 3-8023-0744-5
• Dr. LOGO Benutzerhandbuch, Digital Research, ISBN 3-89090-116-6