% Content-encoding: UTF-8
\documentclass[ngerman]{article}
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\setcounter{secnumdepth}{0}
\setcounter{tocdepth}{0}

\begin{document}

\title{False Forth in der c't — eine Artikelbesprechung}
\ifx\shorttitle\undefined\else
\shorttitle{False Forth}
\fi
\author{Fred Behringer}

\begin{document}\label{falseforth}
\maketitle

\begin{tabular}{lll}
Exoterisch &=& allgemein verständlich.\\
Esoterisch &=& geheim gehalten.\\
Exotisch   &=& anziehend, weil fremdländisch.\\
\end{tabular}

\begin{multicols}{2}
Martin Luther verfasste seine Schriften in einer Mischung aus Deutsch und Latein. Ich schließe mich an, wobei ich Latein durch Englisch ersetze. 

FALSE ist kein Akronym, also schreibe ich False. Die falseschen Zitate lasse ich in der Originalsprache stehen. Zwischen Zitaten und Erklärungen unterscheide ich nur lasch. 

Eigentlich soll die Anordnung und Auswahl der Zitate Erklärungen erübrigen. Um aber ein ganz klein bisschen Ordnung ins Geschehen zu bringen, kennzeichne ich Zitate da, wo es leicht geht, mit Anführungszeichen (\LaTeX--Adepten würden hier wahrscheinlich Kursivschrift bevorzugen).

In der Nummer 22 der Zeitschrift c't vom 15.10.2007 auf den Seiten 192 bis 199 steht ein amüsanter Artikel über esoterische und exoterische Sprachen in einer für den Außenstehenden sehr verständlichen Ausführung mit höchst interessantem Hintergrund. Auch eine halbe Seite über den Begriff der Turing--Maschine fehlt nicht. (Ist Forth Turing--vollständig? Welches \glqq Forth\grqq\  : ANS, ANS--Core, Forth als System in einer gegebenen Implementation?) Weiteres siehe weiter unten.

Zuvor noch eine Mail vom Chaos Computer Club an das Forthbüro:

\glqq 
\begin{tt}Betreff: Forth auf dem 21c3?
\begin{verbatim}
Datum: Sun, 7 Nov 2004 20:53:08 +0100
Von: Corinna <corinnaATgeekinDOTde>
An: secretaryATforth-evDOTde

Hallo Forth-Team!

Wir suchen noch ReferentInnen fuer den 21. 
Chaos Communication Congress zwischen 
Weihnachten und Neujahr in Berlin. 
"Wir" sind dabei die Haecksen, also Frauen & 
Maedchen mit CCC-Bezug.
\end{verbatim}

Geplant ist ein Schwerpunkt auf exotischeren Programmiersprachen und Forth zaehl ich mal dazu :-)\end{tt}\grqq\  

Soviel zur Meinung der Außenwelt über Forth. Nun zum c't--Artikel von Oliver Lau:

\glqq So richtig verständlich ist allerdings auch manch exoterische Sprache nicht --- weshalb sie dem ein oder anderen vielleicht esoterisch vorkommen mag, etwa das fakten-- und regelbasierte Prolog, Lisp mit dem Faible zu verketteten Listen oder Forth mit seiner gewöhnungsbedürftigen umgekehrten polnischen Notation (UPN)\ldots\grqq\ 

Demnach ist Forth ganz normal exoterisch, es erscheint nur manch einem esoterisch --- wegen der Umgekehrt--Polnischen Notation?

Na, Gott sei Dank! Das hebt Forth natürlich gleich eine halbe Stufe höher. Und wenn man die UPN wegnähme? Wird dann aus Forth eine hoffähige Sprache? Oder umgekehrt: Wenn man die UPN wegnimmt, bleibt Forth dann noch Forth?

Nicht umsonst hat unsereiner das berühmt--berüchtigte Interview mit Chuck Moore beim Versuch einer gerechten Wiedergabe im Deutschen in sich hineingesogen. Here comes what the Forth--Erfinder dazu meint (siehe VD--Heft 4 vom Jahre 2002, Seite 7 bis 14):

\glqq Forth liefert kaum etwas Neues, aber die Zusammensetzung seiner Bestandteile ist einzigartig. Ich bin den Menschen und Einrichtungen, die es mir --- zumeist ohne ihr Wissen --- erlaubt haben, Forth zu entwickeln, dankbar. Und dankbar bin ich Ihnen dafür, dass Sie genug Interesse aufbringen, etwas darüber zu lesen.\grqq\ 

Also doch: Jeder einzelne Bestandteil von Forth war und ist bekannt --- und damit höchst exoterisch. Nimmt man aber einen einzigen davon weg, ist es nicht mehr Forth. Auf die geniale Zusammensetzung kam und kommt es an. Und die verdanken wir Charles (Chuck) Moore.

Als ob UPN esoterisch wäre! Kein Mensch hätte einen HP--Taschenrechner esoterisch genannt.

Und weiter beim c't--Autor Lau:

\glqq Esoterische Sprachen entstehen typischerweise nicht mit Hinblick auf praktische Nutzbarkeit, sondern vielfach, weil jemand extremen Ehrgeiz und Aufwand in einen Teilaspekt investiert --- oder einfach mal aus Jux.\grqq\ 

\glqq Zu den Turing--vollständigen Sprachen gehört zum Beispiel False, die der Niederländer Wouter van Oortmerssen im Jahr 1993 entworfen hat. Der Name: Eine Remineszenz an seinen Lieblings--Boolean--Wert. Der Anspruch: Eine mächtige Sprache mit einer möglichst verwirrenden Syntax zu entwerfen, die ein möglichst winziger Compiler in Maschinencode übersetzt. Van Oortmerssen lieferte auch gleich den Machbarkeitsbeweis in Gestalt einer nur 1024 Byte großen 68k--Assembler--Implementierung für den Amiga.\grqq\ 

Der c't--Autor, Oliver Lau, spricht von Turing--vollständigen Sprachen. Wo finde ich eine saubere Definition des Begriffs \glqq Sprache\grqq, einer Definition, mit welcher man bei der Untersuchung der T(uring)--Vollständigkeit arbeiten kann? Ist Forth T--vollständig? Ist nicht jede offene Computersprache T--vollständig? Gibt es außer Forth noch andere offene Computersprachen? False ist wohl nicht offen? Denn dann müsste es ja (als Sprache) in seinen Compiler (als System) eingreifen können (?) Fragen über Fragen (an die Informatiker und Forth--Fachleute).

Ein Charakteristikum von False scheint darin zu bestehen, dass bis zu 256 unterscheidbare Einzelzeichen, aber auch nur solche, als Befehle Verwendung finden. (Befehlszusammensetzungen sind möglich.) Es war für die vorliegende Besprechung nicht ganz sicher, welchen Zeichensatz die Vorlage des Handbuches von Wouter van Oortmerssen ursprünglich verwendete. Ich habe mich an Courier New (in NotePad und Word) gehalten und es dem Redakteur der VD überlassen, daraus ein brauchbares Satzbild zu machen. Wenn Zeichen in meiner Besprechung von False false wiedergegeben werden (man kommt sich vor wie Evelyn Hamann beim Witherspoon--Sketch), ist das auf den eben genannten Umstand zurückzuführen.

Übrigens sind 256 mögliche einstellige Befehle eine ganze Menge! Gforth--R8C hat 528 \glqq Befehle\grqq\  --- und die haben mir beim Elektor--Glossar schon ganz schön zu schaffen gemacht. 

Sollten es aber wirklich nur die Einsparungen durch Übergang zu einbuchstabigen Forth--Worten sein? Dann könnte man ja vielleicht eine umkehrbar eindeutige (eine bijektive) Beziehung zwischen Forth--Wortschatz und False--Wortschatz herstellen? Mal versuchen! Erleichtert wird ein solches Vorhaben natürlich durch den Umstand, dass ja der Compiler bei False \glqq außen vor\grqq\   bleibt. Man nehme in Forth den gesamten Colon--Compiler (das sind wohl hauptsächlich die Compile--Only--Worte aus ANS--Forth --- die Kontrollstruktur--Worte wiederum aber auch wieder nicht?) heraus! Was bleibt für die eigentliche Sprache \glqq Forth\grqq\   dann noch übrig? Eine wirklich minimalistische Sprache Forth?

Was mich betrifft, mich hat der in Forth geschriebene Forth--Compiler zur Freizeit--Beschäftigung mit Forth verleitet. Nicht unbedingt der dahinterstehende Meta--Compiler, der das gesamte Forth--System als Anwendungsprogramm zu schreiben gestattet. Der Colon--Compiler aber auf jeden Fall.

Und nun weiter beim c't--Autor Oliver Lau:

\glqq Wer Forth kennt oder etwas mit umgekehrter polnischer Notation (UPN) anzufangen weiß, kommt mit Forth recht flott voran. Folgender Code berechnet zum Beispiel (1+2)*4: 1 2 + 4 * \grqq\  

und so weiter und so fort.

Aus dem Artikel ist nicht zu erkennen, ob beispielsweise zwischen 2 und + ein Leerzeichen als Trennzeichen liegt. Eine gewisse Antwort bekomme ich aus dem Beispiel der Fakultätsfunktion im Artikel von Lau und die anschließenden weiteren Erklärungen:

\glqq Das Beispiel entbehrt nicht einer gewissen Ästhetik, die gewiss verlöre, wenn man den Code mit Leerzeichen, Einrückungen oder Zeilenumbrüchen entzerren würde. Wohl auch deshalb resümiert van Oortmerssen: Einrückungen, Leerzeichen und Kommentare sind für Nulpen; der wahre False--Programmierer schreibt kompakten (dichten) Code und greift auf Variablen höchstens für Funktionsdefinitionen zurück, aber nicht als Alternative zur Ablage von Werten auf dem Stack. Sicherlich war van Oortmerssen bewusst, dass der englische Begriff \glqq dense\grqq, den er im False--Handbüchlein verwendet, nicht nur \glqq dicht\grqq, sondern auch \glqq blöd\grqq\   bedeutet.\grqq\  

Der c't--Artikel \glqq Hexenwerk --- ein Plädoyer für esoterische Programmiersprachen\grqq\   von Oliver Lau hat mich neugierig gemacht, insbesondere False. Das wollte ich genauer wissen und ich fing an, im \glqq False--Handbüchlein\grqq\   zu \glqq blättern\grqq\   (siehe unten). Einen Forth--Compiler von 1024 Byte Länge hätte ich liebend gern. (In den Home--Computer--Zeitschriften war früher viel von 1k--Programmen die Rede. Kurze Programme, die nur das tun, wofür sie entworfen wurden, das aber richtig.) Der c't--Autor Lau geht in seinem Plädoyer für esoterische Sprachen in weiteren Abschnitten auf Brainfuck, Befunge, Whitespace und INTERCAL ein. Die lasse ich aus. Für das Erstgenannte besorge ich mir erst einen DUDEN der Gossensprache. Und einen Webster und ein \glqq Oxford Concise Dictionary der Wörter der übleren Sorte\grqq\   muss ich mir auch noch heraussuchen. Bis zum nächsten Mal.

Ich darf also jetzt zu False übergehen und einige Zitate aus dem \glqq Handbüchlein\grqq\ (immerhin 11 Seiten) bringen, um Wouter van Oortmerssens Bemühungen zu 
skizzieren.
\end{multicols}

\glqq\begin{tt}The language FALSE and its compiler were designed for only two reasons:
\begin{verbatim}
- building a working compiler in just 1k (!)
- designing a language that looks cryptic and fuzzy (in the APL tradition).

The result is a language that is quite powerful (for its size).
It's a Forth type language with lambda abstraction and lots of other goodies.
I named the language after my favourite truthvalue. 

I suppose you really have to be a Forth hacker or a hardcore programmer to get the most of it.

FALSE inherits its way of evaluating expressions from Forth, so it
really helps if you know that language, but for those who don't:

All elements in the language are defined by what they push on and/or
pop from the stack. For example, a number like "1"  or "100"  simply
pushes its own value on the stack. An operator like "+"  takes the
two top elements of the stack, adds them, and pushes back the result:

1 2 + 4 *	{ (1+2)*4 }

The result of this expression is "12" . And this is the fac() function definition in FALSE:

[$1=$[\%1\]?~[$1-f;!*]?]f:

A FALSE lambda function is a piece of code between []. For example: [1+] is a function that adds 
1 to its argument. 2[1+]! would result in "3" .

Control structures: FALSE only has an IF and a WHILE.

FALSE language overview:

syntax:     pops:      pushes:      example:       comment:
            -->top     -->top
----------- ---------- ------------ -------------  ------------------------
{comment}   -          -                           { this is a comment }
[code]      -          function     [1+]           { (lambda (x) (+ x 1)) }
a .. z      -          varadr       a              { use a: or a; }
integer     -          value        1
'char       -          value        'A             { 65 }
num`        -          -            0`             { emitword(0) }

:           n,varadr   -            1a:            { a:=1 }
;           varadr     varvalue     a;             { a }
!           function   -            f;!            { f() }

+           n1,n1      n1+n2        1 2+           { 1+2 }
-           n1,n2      n1-n2        1 2-
*           n1,n2      n1*n2        1 2*
/           n1,n2      n1/n2        1 2/
_           n          -n           1_             { -1 }

=           n1,n1      n1=n2        1 2=~          { 1<>2 }
>           n1,n2      n1>n2        1 2>

&           n1,n2      n1 and n2    1 2&           { 1 and 2 }
|           n1,n2      n1 or n2     1 2|
~           n          not n        0~             { -1,TRUE }

$           n          n,n          1$             { dupl. top stack }
%           n          -            1%             { del. top stack }
\           n1,n2      n2,n1        1 2\           { swap }
@           n,n1,n2    n1,n2,n      1 2 3@         { rot }
ø (alt-o)   n          v            1 2 1ø         { pick }

?           bool,fun   -            a;2=[1f;!]?    { if a=2 then f(1) }
#           boolf,fun  -            1[$100<][1+]#  { while a<100 do a:=a+1 }

.           n          -            1.             { printnum(1) }
"string"    -          -            "hi!"          { printstr("hi!") }
,           ch         -            10,            { putc(10) }
^           -          ch           ^              { getc() }
ß (alt-s)   -          -            ß              { flush() }
\end{verbatim}
\end{tt}\grqq\ 

\begin{multicols}{2}
Soweit der Überblick von W. van Oortmerssen über seine Sprache False. (Und schon fängt es mit den systemabhängigen typografischen Inkompatibilitäten an: alt--s liefert bei mir unter Word 2000 etwas \glqq Furchtbares\grqq, alt--o liefert gar nichts. \glqq Wir\grqq\ wissen, wo wir unser ß herbekommen! Das liegt auf der deutschen Tastatur oben rechts. Aber bei ø müssen wir uns schon was einfallen lassen.) 

Das möge genügen. Und hier noch die Beweggründe des False--Schöpfers zur Erschaffung seiner Sprache:

\glqq FALSE was created for fun, just to see how small a compiler I could write while still compiling a relatively powerful language.\grqq\  

W.~v.\ Oortmerssen gibt Hinweise auf weitere Quellen zum Thema:

\glqq Steinar Knutsen has been so friendly to set up an FTP site so
all you people can put your False related products there!

\url{ftp://ftp.nvg.unit.no/pub/lang/false/} for the distribution.\\
\url{ftp://ftp.nvg.unit.no/pub/lang/false/src/} for sources not in the distribution.

Chris Pressey has a False homepage at:

\url{http://www.cats-eye.com/cet/soft/lang/false/}

Ben Hoyt (benhoytATclearDOTnetDOTnz) has made a full implementation of False as both interpreter and compiler (for 386 DOS) written in ANSI--Forth! The source code is something to be seen. Get the archive at: 
\url{http://wouter.fov120.com/files/lang}\\ \url{/false/forth_false.zip} .\grqq\  

Diesen \verb|forth_false.zip|, wenn er schon mal something to be seen ist, habe ich mir mal angeschaut. Ausprobieren wollte ich den in Forth geschriebenen False--Interpreter und den ebenfalls in Forth geschriebenen False--Compiler von Ben Hoyt (2000) auf den Systemen 32/FORTH 3.07 (DPMI--getrieben) von Rick VanNorman (1993) und MinForth 1.5 von Andreas Kochenburger. Beide sind, wie von Ben Hoyt gefordert, 32--Bit--Systeme. \glqq Fully ANS compliant\grqq. Aber: Ein ANS--Forth--System, das ist hinreichend bekannt und man wagt es kaum, es zu wiederholen, ist genau ein ANS--Forth--System. Nicht die Sprache. Die ist fully standardisiert. Aber das System, mit dem man es zu tun bekommt. Nun, bis zur Überprüfung der Definierbarkeit der (generischen) Lambda--Funktion [1+]i: bin ich nicht vorgedrungen. (Die darin enthaltene eigentliche False--Lambda--Funktion heißt [1+].) In beiden Systemen nicht. Im MinForth--System zeigte der Bildschirm wenigstens die Erkennungsmeldung

  Portable False interpreter in Forth --- by Ben Hoyt --- 5 February 2000

an. Aber der Forth--Quelltext von Ben Hoyt ist prima verständlich und die genauere Untersuchung halte ich mir für später auf.

W.~v.\ Oortmerssen schließt mit folgenden Danksagungen ab:

\glqq I want to thank the people who contributed sourcecode, among others:

Ben Schaeffer, Ed Mackey, Eelko de Vos (and the rest of The TU--Delft False Fanclub, Maarten and Rene), Herb Wollman, Lionel Vintenat, Marcel van Kervinck, Peter Bengtsson, Steinar Knutsen, Thomas Fischbacher, and Tomas Partl

and the many more people that have shown their interest in the language. 
One of them put it like this:

\begin{quote}
  \#define FLAME ON
  Dear Mr.\ Wouter van Oortmerssen, Sir, Bwana!
  
  We (FORTH enthusiasts of Southern German Banana Republic
  of Bavaria) are not amused by your FALSE language.
  
  No Sir, not at all.
  
  Some of us are still jumping up and down in the coconut tree
  muttering obscenities like \glqq DUP RECURSE that *@! Oortmerssen!\grqq.
  (Some are say even things like \glqq 'Oortmerssen EXECUTE\grqq)
  
  You have had the intention of writing an absolutely cryptic
  while extreme terse \& powerful language. In that you've
  succeeded marvelously.
  Yet why, Great Moore! have you taken FORTH for the template?
  Forth is quite cryptic already, yet you must you render it
  completely unreadable. In Bavaria this is regarded as a
  grave public offense, sentenceable to not below of 3 years
  of pure K\&R C programming. You could plead for clemency by
  pointing out your having introduced the lambda computational
  concept into FORTH, though.
  I will grant you that much.\grqq\  
\end{quote}

Die Einrückung kennzeichnet das Zitat im Zitat. 

W.\ van Oortmerssen ist (oder war zum Zeitpunkt der Erstellung seiner momentanen Homepage) Lecturer at the Guildhall. Ob er wohl eine Möglichkeit gesucht hat, seinen Studenten ohne viel Federlesens Erfolgserlebnisse beim Computersprach-- oder/und Compiler--Studium zu verschaffen? 

Hier die Anschrift des False--Schöpfers: OortmersATfwiDOTuvaDOTnl

Zurück zur Besprechung des c't--Artikels von Oliver Lau: Ich kann (als Rezensent) nicht genau erkennen, in welche Reihe der c't--Autor Forth tatsächlich einstuft, exoterisch, exotisch oder esoterisch.

Albert Nijhof in seinem Arbeitsbuch \glqq De Programmeertaal FORTH\grqq\   (deutsche Übersetzung beim mv--Verlag): \glqq Forth is de computertaal die het best geheim gehouden is.\grqq\   (Dick Pountain)

Der Rezensent: Dus toch esoterisch?
\end{multicols}
\end{document}

