Pilot Atari: Die logische Sprache

In der letzten Zeit erschien ein ganzer Haufen an neuen Programmiersprachen. Eröffnet wurde dieser Reigen von PILOT.

Auch wenn es für nicht-Programmierer manchmal so erscheint, als ob es nur eine Handvoll an Programmiersprachen gibt, so existieren doch im Untergrund, in Firmen und an Universitäten hunderte. Zweifellos wird eine Sprache aber eher wahrgenommen, wenn eine große Firma dahintersteht. Es darf darüber spekuliert werden, ob Sprachen wie Java oder C# die gleiche Aufmerksamkeit erzielt hätten, wenn nicht Sun bzw. Microsoft kräftig dafür die Werbetrommel rühren würden. Es entstehen aber ständig neue Sprachen und alte werden neu aufgelegt. Selbst die eigenartigste Sprache wurde nicht ohne Grund erfunden und im Internet gibt es gar eine Gruppe Programmierer, die alte, fast ausgestorbene Sprachen neu belebt. Ob diese Sprachen nun tatsächlich genutzt werden, ist eher zweitrangig.

PILOT

Auch Pilot wurde nicht ohne Grund aus dem Boden gestampft. Ein Problem der damaligen Computer war, das sie viel zu kompliziert zu programmieren waren. Einige US-Amerikanische Schulen hatten zwar einen Computer, aber das Erlernen einer Programmiersprache war zu langwierig sowohl für Lehrer als auch für Schüler. Speziell für diese Zielgruppe wurde an der Universität von Kalifornien Pilot entwickelt, eine Abkürzung für "Programmed Inquiry, Learning, Or Teaching language". Damit ist auch eines der wesentlichen Elemente der Sprache erwähnt: Inquiry (engl. Nachfrage). Ein Pilot-Programm tritt in einen Dialog mit dem Benutzer. Dies kann in etwa mit einem Textadventure verglichen werden. Der Sprachschatz von Pilot ist eher beschränkt, die Syntax extrem einfach und somit ist die Sprache selbst von Anfängern sehr schnell zu erlernen. Basic erscheint im Vergleich mit Pilot komplex und kompliziert. Mit Pilot konnten sich Schüler und Lehrer gleich auf die Problemlösung spezialisieren.
Pilot wurde zuerst im Jahre 1962 veröffentlicht, von der IEEE wurde die Sprache im Jahr 1991 standardisiert - ein weiteres eindrucksvolles Beispiel, wie lange ein Standardisierungsprozess selbst in der schnellebigen Computerbranche dauern kann.

Acht Bits

Nachdem Pilot auf den frühen Computern eine Zeitlang beliebt war, kam es zur zweiten Blütezeit mit den 8-Bit-Computern. Atari veröffentlichte sogar ganz offiziell Pilot für den XL auf Steckmodul. Andere, bekanntere Sprachen wie C und Pascal fühlten sich auf den Heimcomputern nie so richtig heimisch, da sie tw. zwei Diskettenlaufwerke benötigten. Pilot war hingegen sehr klein, genügsam und ein "Quasi-Standard" existierte bereits.
Das Atari Pilot gilt als eine der extravagantesten Varianten von Pilot. Atari erweiterte den Sprachschatz erheblich und führte sogar die aus Logo bekannten Turtle-Grafiken ein - durchgesetzt hat sich diese Erweiterung jedoch nicht. Das Antic Magazine widmete den erweiterten Pilot-Funktionen in Atari Pilot eine ganze Artikelserie.

Heute

Pilot hat sich in den Jahren kaum weiterentwickelt und so ist die Sprache auf 16-Bit-Computern völlig in der Versenkung verschwunden. Kommerzielle Varianten gab es keine mehr, aber in der PC-Public Domain-Szene erschienen ein paar Pilot-Interpreter.
Einer dieser Interpreter stammt von Dave Taylor und ist aus dem Jahr 1985. Dieses Taylor-Pilot entspricht trotz seines Alters weitgehend dem IEEE-Standard. Was sein Programm hervorgehoben hat, ist der Open-Source-Gedanke: der komplette Quelltext in Ansi-C liegt bei. Damit ist eine Portierung auf den ST ein Kinderspiel. Glücklicherweise kümmern sich einige Internet-Seiten um diese alten Quelltexte und betrieben ein regelrechtes "Programmiersprachen-Museum".

Seit 1987 verfügbar ist Tiny-Pilot von B.Rockmann. Diese Implementation wurde speziell für den ST geschrieben und weist sogar eine Menüleiste und Hilfsfunktion auf. Im Gegensatz zum Taylor-Pilot benötigt Tiny Zeilennummern. Interessanterweise ist Tiny komplett in GFA-Basic geschrieben und wird zur Zeit mit faceVALUE überarbeitet, so das bald eine saubere GEM-Version zur Verfügung stehen sollte. Lange Zeit war Tiny verschollen, da es wohl nur auf der Karstadt-PD-Serie veröffentlicht wurde.
Neben diesen beiden Atari-Versionen gibt es noch ein paar Open-Source-Varianten, die vielleicht irgendwann ihren Weg auf den ST finden. RPilot [1] ist ein aktuelles Sourceforge-Projekt. Pilot-Interpreter lassen sich in jeder Sprache schreiben, auf Geschwindigkeit kommt es bei dieser Sprache nicht an.

Taylor-Pilot

Die ST-Umsetzung (Pilot Atari) war in der Version 1.0 bis auf wenige Änderungen völlig identisch zur PC-Version. Dies bedeutet natürlich auch zwangsläufig, dass die Atari-Variante keine grafische Oberfläche bietet. Sie arbeitet jedoch problemlos in jedem VT52-Fenster, wie z.B. dem in MagiC eingebauten. Die Limitierungen, die dadurch entstehen (z.B. keine Grafik) wiegen nicht allzu schwer, da die Pilot-Sprache ohnehin keine Grafik- oder Sound-Befehle kennt. Damit ist eine weitgehende Kompatibilität der Pilot-Varianten untereinander gegeben.

Taylor-Pilot ist ein Pilot-Interpreter und führt die aktuelle Programmzeile auch gleich aus. Ein Editor ist nicht eingebaut und so muß das Pilot-Programm mit einem Texteditor geschrieben werden. Welche Endung das Programm trägt, ist für Pilot unbedeutend. Zum schnellen Testen liegt "Pilot.tst" bei, ein umfangreiches Test-Programm für den Interpreter. Es liefert auch einen guten Überblick über die Sprache. Das Pilot-Programm wird einfach dem Taylor-Pilot übergeben und schon wird die Ausführung gestartet.
Mit der Version 1.1 löst sich Pilot Atari [2] etwas von seinen Wurzeln, denn es sind neue Befehle eingeführt worden, die das Original-Taylor-Pilot nicht kennt. Um die Beispiele dieses Artikels alle nutzen zu können, sollten Sie Version 1.2 von Pilot Atari besitzen.

Tiny-Pilot

Auch Tiny-Pilot ist ein Pilot-Interpreter, jedoch kann im Moment noch nicht abgeschätzt werden, ob diese Version ähnlich leistungsfähig wie das Taylor-Pilot ist. Fest steht, das die Befehlserweiterungen von Pilot Atari auch der Neuauflage von Tiny-Pilot zukommen werden. Tiny besitzt keinerlei Dokumentation, aber ein Hilfsbildschirm zeigt alle möglichen Pilot-Befehle. Programme können direkt im Interpreter eingegeben werden. Ein Beispielprogramm ist mitgeliefert und stellt einen einfachen, wenn auch nicht gerade pädagogischen Spanisch-Vokabeltrainer dar.
Das interessanteste dürfte wohl der Quelltext in GFA-Basic 2.0 sein. Das Programm sieht wie ein typischen Atari-PD-Programm von 1987 aus und kritzelt ungeniert auf den Bildschirm.

Hallo Welt!

Das erste Pilot-Programm ist, wie sollte es anders sein, das berühmte "Hallo Welt!". Starten Sie dazu einen Texteditor und tippen Sie folgende Zeile ein:

T: Hallo Welt!

Einfach, oder? Dieses Mini-Programm wird als "hallowelt.plt" gespeichert und als Parameter dem pilot.tos übergeben. Der Pilot-Interpreter gibt nun den Text "Hallo Welt!" aus und beendet sich.
In Pilot ist es üblich, die Befehle abzukürzen. "T" ist die Abkürzung für "TYPE" und gibt Text auf den Bildschirm aus. Manche Pilot-Varianten erlauben auch die Verwendung ausgeschriebener Befehle:

TYPE: Hallo Welt!

Dieses ist jedoch derzeit in Pilot Atari nicht zulässig. Dafür funktioniert folgendes Beispiel:

T: Pilot ist toll.
 : Pilot ist doof.
 : Pilot ist ...

Zeile zwei und drei kommen ohne Befehle daher, trifft der Pilot-Interpreter aber auf eine solche Zeile, wiederholt er einfach die letzte ausgeführte Anweisung, also "T".

Kommentare

Das "R"-Kommando fügt einen Kommentar ein, der vom Interpreter ignoriert wird:

R: Kommentar

Variablen

Pilot unterscheidet nicht zwischen Groß- und Kleinschreibung bei Variablen. In Variablen werden Benutzereingaben gespeichert und Berechnungen durchgeführt. Pilot kennt allerdings nur zwei Variablentypen: Strings und numerische. Letzere umfassen den gleichen Wertebereich wie Integer-Variablen in anderen Sprachen (in Pilot Atari -32000 bis 32000). Variablennamen können bis zu 10 Zeichen lang sein, Umlaute oder ähnliche Sonderzeichen (Ausnahme: der Unterstrich "_") sollten nicht verwendet werden.
Um Strings und numerische Variablen zu unterscheiden, bekommen sie ein Zeichen vorangestellt:

$hallo - ist eine String-Variable  
#hallo - ist eine numerische Variable

Obwohl beide Variablen den gleichen Namen haben, werden sie unabhängig voneinander verwaltet.

Variablen belegen

Um etwas mit einer Variable anzufangen, muß sie zunächst einen Wert zugewiesen bekommen. Dazu existiert der "C"-Befehl (Compute: berechnen). Eine einfache Belegung sieht so aus:

C: #answer = 1

Natürlich können auch Berechnungen mit diesem Kommando durchgeführt werden. Pilot Atari kennt neben den vier Grundrechenarten noch Klammern.

Strings werden auf die gleiche Weise definiert. Im Gegensatz zu anderen Sprachen muß man den Stringinhalt nicht in Anführungszeichen setzen.
Mit dem Compute-Befehl können Strings verknüpft werden:

C: $text1 = Hallo
C: $text2 = Welt
C: $text3 = $text1 $text2

In dem String $text3 wird "Hallo Welt" stehen.

Usereingaben

Die bisherigen Kenntnisse reichen aus, um Berechnungen durchzuführen und ein paar nette Texte auszugeben. Mit Usereingaben wird das Programm interaktiv und flexibel. "A" (Accept) fordert eine Eingabe vom Benutzer und legt den Wert in einer Variablen ab:

A: #zahl

Die Eingabe von Strings erfolgt analog.

Werte ausgeben

Ein Programm mit Variablen macht wenig Sinn, wenn der Inhalt nicht ausgegeben wird. Das entsprechende Kommando kam bereits beim ersten Beispiel zum Einsatz und kann auch den Inhalt von Strings oder numerischen Variablen ausgeben. Damit dies geschieht, muß einfach der Variablenname eingesetzt werden:

C: $test = STC
T: Kürzt man ST-Computer ab, erhält man... $test

$test in der zweiten Zeile wird automatisch durch den Variablenwert ersetzt. Es darf auch mehr als eine Variable in einer Zeile vorkommen, nur Berechnungen sind innerhalb des "T"-Kommandos nicht möglich. Damit sind wir in der Lage, die Beispielprogramme 2 und 3 zu verstehen.

Labels

Labels definieren eine Stelle, die über ein Pilot-Kommando angesprungen werden kann. Da Pilot Atari keine Zeilennummern kennt, kann nicht einfach durch Angabe einer Nummer auf eine bestimmte Zeile verzweigt werden.
Die Syntax, in der Labels definiert werden, weicht etwas vom Standard ab:

*einziel

Für die Schreibweise von Labelnamen gilt das gleiche wie für Variablen.
Um nun ein Label anzuspringen, wird das "J"-Kommando (Jump) eingesetzt, das dem "GOTO" in Basic entspricht:

J: *einziel

In manchen Pilot-Varianten wird der Stern "*" weggelassen - Pilot Atari benötigt ihn aber unbedingt! Eine Erweiterung des Euro-Rechners mit Rücksprungmöglichkeit sehen Sie in Listing 4. Wenn Sie dieses Programm aber eintippen und starten, werden Sie merken, dass eine seltsame Parität zwischen Euro und DM eingetreten ist. Woran liegt es? Ganz einfach: als Zahlentyp kennt Pilot nur den aus C bekannten Integer. Dieser kennt aber keine Nachkommastellen - aus 1.95583 wird also 1.

Umfangreiches Vergleichen

Pilot war auch deshalb an Schulen so erfolgreich, weil es auf einfache Weise Programme möglich machte, die vom üblichen Multiple Choice-Stil abwichen. Es ist ein leichtes, eine Usereingabe anzufordern und dann zu prüfen, ob die Eingabe gültig ist oder nicht.
Das Match-Kommando ("M") vergleicht die letzte User-Eingabe mit einer Liste von Strings. Wenn Pilot eine Übereinstimmung findet, wird die Variable #matched auf 1 gesetzt und #which auf die Position der Übereinstimmung.

T: Nennen Sie einen bekannten Heimcomputer-Hersteller!
A: $hersteller
M: Atari Apple Commodore Sinclair Amstrad Tandy

Wird bspw. "IBM" eingegeben, nimmt #matched den Wert 0 an. Wenn Sie z.B. Commodore eintippen, ist der Wert von #matched 1 und #which wird auf 3 gesetzt.

YesYesNoNo

Damit das Programm eine Fehleingabe bei dem letzten Beispiel nicht einfach so hinnimmt, gibt es eine einfache Vergleichsmöglichkeit. Die Kommandos TY und TN greifen auf #matched zu und geben einen Text aus, wenn #matched größer als 0 ist (TY) bzw. gleich 0 ist (TN). TY ist die Abkürzung für "TYPE YES" und TN für "TYPE NO".
In der Version 1.15 von Pilot Atari gibt es eine Abkürzung für die Abkürzung: Y und N. Zwar wird normalerweise immer TY/TN verwendet, aber aus Gründen der Kompatibilität zu rpilot wurde Pilot Atari erweitert.
Beispielprogramm 5 ist das "Heimcomputer-Programm", erweitert um eine Antwort des Interpreters.

Unterprogramme

War das "J"-Kommando äquivalent zu "GOTO" in Basic, so gibt es auch das GOSUB in Pilot.
Ein Unterprogramm wird mit einem Label-Bezeichner eröffnet. Danach kommen die Anweisungen der Unterroutine, die mit dem "E"-Kommando beendet wird. Der Interpreter springt nun zum nächsten Befehl, der nach dem Unterprogrammaufruf steht. Wurde kein Unterprogramm aufgerufen, beendet "E" das Programm.
Unterprogramme werden nicht mit "J", sondern mit "U" (Use) aufgerufen. Beispielprogramm 6 illustriert dies.

Komplexe Bedingungen

Die einzigen Bedingungen die wir besser kennen gelernt haben, sind TY und TN. Die Pilot-Syntax kennt aber noch komplexere Bedingungen, die direkt hinter dem Kommando definiert werden:

T(#alter>=18): Wow, schon volljährig!

Der Text wird nur dann ausgegeben, wenn #alter größer oder gleich 18 ist. In der Bedingung können auch die üblichen mathematischen Operationen durchgeführt werden:

T(#wuerfel1+#wuerfel2=12): Ein Pasch!

Die Operatoren sind: =, <, >, <> (Ungleich), <= (kleiner/gleich), >= (größer/gleich).
Eine solche Bedingung kann hinter jedem Pilot-Befehl stehen.

Pilot-Erweiterungen

Die Version 1.0 von Pilot Atari beherrschte praktisch nur das Standard-Pilot. Es gab von einigen Pilot-Dialekten diverse Befehlserweiterungen, die nicht ihren Weg in den IEEE-Standard fanden. Damit nun Programme dieser Dialekte auch mit Pilot Atari genutzt werden können, kamen in der Version 1.1 neue Befehle hinzu. Wie immer, wenn ein Standard verlassen wird, leidet die Portabilität. Nicht jede Pilot-Variante beherrscht die neuen Befehle und Pilot Atari kennt längst nicht jede Befehlserweiterung von Pilot. Leider sind im Internet Programmiersprachen für 8-Bit-Systeme kaum zu finden, sonst könnten noch mehr Erweiterungen von Atari Pilot (für den XL) integriert werden.

Pause (PA) pausiert das Programm für eine bestimmte Anzahl Sekunden. Diese Erweiterung stammt von Nevada und Atari Pilot:

PA(#test<4): 5

...wartet 5 Sekunden, wenn #test kleiner als 4 ist.

Typehang (TH) entspricht dem Type-Kommando. Der einzige Unterschied ist, das nach der Ausgabe des Textes kein Zeilenumbruch erfolgt.

Clearhome (CH) löscht den Bildschirm.

Color (CO) ändert die Textfarbe. Dieses Kommando ist exklusiv für Pilot Atari:

CO: 1

Es sind die 16 Standardfarben ansprechbar. 0 ist auf vielen Systemen weiß, 15 schwarz. Natürlich kann auch der CO-Befehl eine Bedingung enthalten.

Die folgenden Kommandos werden von der Version 1.15 nicht interpretiert, kommen aber in aktuellen Pilot-Interpretern vor.

Execute (X) führt Pilot-Code aus, der sich in einer Variablen befindet. Damit läßt sich selbst-modifizierender Code erstellen.

Shell (S) führt einen Betriebssystembefehl aus. Dies ist in kommandozeilenorientierten Betriebssystemen kein Problem, auf dem Atari ist das Kommando zu vernachlässigen.

Generate (G) wird den Weg in Pilot Atari finden. "G" kreiert eine Zufallszahl und ist damit wichtig für Spiele.

Position (POS) positioniert den Cursor an einer bestimmten Stelle.

Übertragung von anderen Dialekten

Pilot Atari ist nicht vollständig kompatibel zu den alten 8-Bit-Dialekten. Grafik- und Soundbefehle existieren nicht. Einfache Programme müßten nach dem Entfernen der Zeilennummern laufen. Beim Atari Pilot können einzelne Speicherzellen angesprochen werden (ähnlich POKE in Basic):

C: @B53248=#X

Somit können natürlich nette Effekte erzielt werden, übertragbar auf den ST ist ein solches Programm aber nicht. Zudem widerspricht dies dem Konzept von Pilot als Lehrsprache.

Fazit

Pilot Atari ist einfach, aber durchaus leistungsfähig genug für einige interessante Projekte. Besonders Anfänger finden hier einen leichten Einstieg in die Welt des Programmierens.
Zur Zukunft von Pilot Atari sei soviel gesagt, das zumindest das "G"-Kommando sicher eingebaut wird. Es ist aber auch gut möglich, das Pilot Atari ganz eingestellt und statt dessen an einer Atari-Version von rpilot gearbeitet wird.

Beispiel 2

R: Einfaches Namen-Programm
T: Hallo, wie heißt Du mit Vornamen?
A: $vorname
T: Und der Nachname?
A: $nachname
T: Sehr erfreut, $vorname $nachname!

Beispiel 3

R: Rechner
T: Verdoppeln Sie Ihren Einsatz:
A: #einsatz
C: #doppelt = #einsatz*2
T: Neuer Wert: #doppelt.

Beispiel 4

R: Eurorechner
*anfang
T: Wert in DM eingeben:
A: #dm
C: #euro = #dm/1.95583
T: Das sind #euro Euro.
 : Drücken Sie "Return", um einen weiteren Wert auszurechnen
A: $antwort
J: *anfang

Beispiel 5

T: Nennen Sie einen bekannten Heimcomputer-Hersteller!
A: $hersteller
M: Atari Apple Commodore Sinclair Amstrad Tandy
Y: Richtig, $hersteller ist ganz schön bekannt!
N: $hersteller ist nicht wirklich ein Heimcomputer-Hersteller, oder?

Beispiel 6

U: *unterprog
T: Unterprogramm beendet!
J: *beenden
*unterprog
T: Mitten im Unterprogramm!
E:
*beenden

Quellen:
[1] rpilot.sourceforge.net
[2] http://www.jaapan.de/software/programmiersprachen/
Matthias Jaap


Links

Copyright-Bestimmungen: siehe Über diese Seite
Classic Computer Magazines
[ Join Now | Ring Hub | Random | << Prev | Next >> ]