Whitespace (Programmiersprache)

aus Wikipedia, der freien Enzyklopädie
Zur Navigation springen Zur Suche springen
Whitespace-Quellcode mit Syntax-Highlighting
  • Tabulatorzeichen
  • Leerzeichen
  • Whitespace ist eine relativ junge esoterische Programmiersprache. Die Befehle und Steueranweisungen bestehen im Gegensatz zu üblichen Programmiersprachen aus definierten Folgen von Leerzeichen, Tabs und Zeilenumbrüchen (engl. Whitespaces). Neben dieser offensichtlichen Eigenart verwendet Whitespace das übliche Dualsystem nur für Daten; der Programmcode wird in einem dreiwertigen Stellensystem („l“, „t“, „u“ oder engl. “s”, “t”, “l”) abgebildet.

    Syntax[Bearbeiten | Quelltext bearbeiten]

    Die Befehle und Steueranweisungen bestehen aus definierten Folgen von Leerzeichen (l), Horizontal-Tabulatorzeichen (t) und Zeilenumbrüchen (u).

    Es gibt kein Syntaxelement zur Kennzeichnung von Kommentaren. Stattdessen können Kommentare, die selbst keine Whitespaces enthalten dürfen, an beliebigen Stellen im Quellcode eingegeben werden. Der Interpreter ignoriert alle Zeichen, die für ihn keine Bedeutung haben.

    Befehle[Bearbeiten | Quelltext bearbeiten]

    Die Befehle lassen sich grob in fünf Bereiche einteilen:

    Zeichen Bedeutung
    l Stack-Zugriff
    tl Rechenfunktionen
    tt Heap-Speicher-Zugriff
    u Schleifen, Sprünge, Bedingungen
    tu Ein- /Ausgabe von Werten

    Eine genaue Beschreibung der einzelnen Befehle inklusive erwarteter Parameter befindet sich auf der unten genannten Webseite.

    Daten[Bearbeiten | Quelltext bearbeiten]

    Während die Befehle ein dreiwertiges Stellensystem verwenden, werden die Daten im dualen System abgebildet: An der ersten Stelle von links steht ein t für eine negative Zahl; ein l für eine positive. Im weiteren Verlauf steht t für 1 und l für 0. Die Spezifikation besagt, dass Zahlen eine beliebige Bitlänge haben können, allerdings können Compiler und Interpreter hier eine sinnvolle Obergrenze festlegen. Abgeschlossen wird ein Datum durch einen Zeilenumbruch.

    Sprache[Bearbeiten | Quelltext bearbeiten]

    Whitespace ist eine imperative, stackbasierte Programmiersprache, die den Programmierern einen Stack und Heap zur Verfügung stellt.

    Alle Operationen arbeiten intern auf Ganzzahlen beliebiger Bit-Länge. Es besteht allerdings die Möglichkeit, ein Zeichen auszugeben, das durch seinen ASCII-Code-Wert identifiziert wird (outchar).

    Geschichte und Hintergrund[Bearbeiten | Quelltext bearbeiten]

    Whitespace wurde Ende 2002 von Edwin Brady und Chris Morris entwickelt. Slashdot berichtete am 1. April 2003 über diese Programmiersprache.[1] Mitte 2003, mit der Fertigstellung eines Whitespace-Interpreters in Whitespace, hat die Sprache die Kinderstube verlassen. Bereits fünf Jahre zuvor hatte Bjarne Stroustrup die Idee in einem Entwurf für C++2000 erwähnt. Seine Grundidee war, dass Mathematiker üblicherweise statt des Malzeichens ein Leerzeichen notieren. Diesem Leerzeichen könnte man also in C++2000 die Bedeutung der Multiplikation zuordnen.[2]

    Whitespace zeigt eine gewisse Ähnlichkeit mit Python-Programmen und make-Dateien, denn dort steuern Tabulatorzeichen am Zeilenanfang den Programmablauf. Die meisten anderen Programmiersprachen ignorieren Whitespaces. Für den menschlichen Betrachter dienen sie jedoch einer nützlichen Strukturierung, die den Programmcode besser lesbar machen kann.

    Vorteile seien laut den Erfindern, dass massenhafte Ausdrucke von Quelltexten Tinte sparen und dass Spione, die Code entwendet haben, diesen nicht entschlüsseln können. Allerdings bleiben noch Probleme bestehen, wenn man den Code nach dem Ausdrucken wieder eingeben möchte.

    Whitespace eignet sich besonders gut zum Verbergen von Programmcode in normalem Text ähnlich der Steganographie. Ein Beispiel dafür findet sich in einem Beitrag des International Obfuscated C Code Contest.

    Hello World[Bearbeiten | Quelltext bearbeiten]

    Das oben dargestellte „Hello, world!“-Programm:

     lllullltlltllluttlllltulllttlltltuttlllltlulllttlttlluttllllttulllttlttlluttllll
     tllulllttlttttuttlllltltullltlttlluttllllttlullltllllluttlllltttullltttltttuttll
     lltlllulllttlttttuttlllltlltullltttlltluttlllltltlulllttlttlluttlllltlttulllttll
     tlluttllllttllullltlllltuttllllttltulllttltuttlllltttlullltltluttllllttttullllut
     tllllluulllltulultttlulutlltlutullllltutlllululltuullltluuuu
    

    Entwicklungsumgebungen[Bearbeiten | Quelltext bearbeiten]

    Der Editor Vim bietet von Haus aus ein Syntax-Highlighting für Whitespace an, wodurch die Programmierung deutlich vereinfacht wird. Dies läuft allerdings einem Designziel der Sprache, beim Ausdruck möglichst wenig Tinte zu verbrauchen, entgegen. Einen Mode für Emacs gibt es bei den Weblinks.

    Das oben und unten dargestellte "Hello, world!" kann mit einem der folgenden Skripts in richtiges Whitespace konvertiert werden:

     #!/bin/sh
     sed "s/ //g;s|//.*||g;s/\\n//g" $1 | tr -d '\n' | sed "s/l/ /g;s/t/\t/g;s/u/\n/g"
    
     #!/bin/sh
     sed "s|//.*||g" < $1 | tr -d " \t\n" | tr ltu " \t\n"
    

    sed ist ein Unix-Werkzeug zur Bearbeitung von Text.

    Whitespace-Assembler[Bearbeiten | Quelltext bearbeiten]

    Da der Umgang mit trinär kodierten Maschinenbefehlen relativ mühsam ist, wird häufig ein äquivalenter Assembler-Dialekt verwendet:

     // "Hello, world!" in den Speicher schreiben
     lllu          // push 0   // Speicherstelle 0
     llltlltlllu   // push 'H' // Zeichen 'H'
     ttl           // store    // in den Speicher
     llltu         // push 1   // ...
     lllttlltltu   // push 'e'
     ttl           // store
     llltlu        // push 2
     lllttlttllu   // push 'l'
     ttl           // store
    […]
     lllttllu      // push 12
     llltlllltu    // push '!'
     ttl           // store
     lllttltu      // push 13
     lllttltu      // push \r
     ttl           // store
     llltttlu      // push 14
     llltltlu      // push \n
     ttl           // store
     lllttttu      // push 15
     llllu         // push 0
     ttl           // store
    
     // Ausgabe-Schleife:
     llllu         // push 0
     ulllltu       // 1:          // /Schleife
        lul           // dup      // | --.
        ttt           // pop      // |   --- Spitze des Stacks untersuchen
        lul           // dup      // | --'
        utlltlu       // jz 2     // | ----> bei 0 sind wir fertig
        tull          // outchar  // | ----> Ausgabe
        llltu         // push 1   // | --._. Speicherstelle hochzaehlen
        tlll          // add      // | --'
     ululltu       // jmp 1       //  \naechster Durchlauf
     ullltlu       // 2:          //
     uuu           // halt        // ende
    

    Literatur[Bearbeiten | Quelltext bearbeiten]

    • Oliver Lau: Hexenwerk – Ein Plädoyer für esoterische Programmiersprachen: In: c’t, 22/2007, S. 192–199.

    Weblinks[Bearbeiten | Quelltext bearbeiten]

    Einzelnachweise[Bearbeiten | Quelltext bearbeiten]

    1. New Whitespace-Only Programming Language, Slashdot, 1. April 2003
    2. Bjarne Stroustrup: Generalizing Overloading for C++2000. (PDF) 1998