Quine (Computerprogramm)

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

Ein Quine ist ein Computerprogramm, das eine Kopie seiner selbst (üblicherweise seines Quelltextes) als Ausgabe schreibt. Es handelt sich somit um eine Form der Selbstbezüglichkeit.

Hacker und Geeks sehen es als sportliche Herausforderung, die kleinstmöglichen Quines in Programmiersprachen ihrer Wahl zu erstellen (siehe IOCCC).

Quines sind nach dem Logiker und Philosophen Willard Van Orman Quine benannt.

Konstruktion von Quines[Bearbeiten]

Frage dich selbst[Bearbeiten]

Ein Quine ließe sich in einem C-ähnlichen Pseudo-Code so schreiben[1]

main() {
    print myself out.
}

Üblicherweise werden C-Programme übersetzt, d. h. die Laufzeitversion des Programms liegt in Maschinensprache vor (Repräsentation als Folge von Bytes, abgespeichert in einer sog. binären Datei), seine ursprüngliche Repräsention ist jedoch in der Regel ein ASCII-codierter Quelltext, der zudem noch in einer anderen Datei abgelegt ist. Der für diesen Ansatz zur Implementierung eines Quines benötigte Zugriff auf die eigene Repräsentation (myself) wäre also sehr kompliziert.

Weiter fordert man für ein Quine, dass es abgeschlossen ist.

  • Es soll ohne Zugriff auf externe Daten auskommen, womit auch der Zugriff auf die eigene Quelltextdatei ausgeschlossen ist.
  • Ebenso soll der wesentliche Code im Quine selbst vorhanden sein, weshalb externe Funktionen nur spärlich genutzt werden sollen, die Bibliotheksfunktion ein Zeichen ausgeben etwa ist noch zulässig.

Nur wenige Sprachen unterstützen Selbstbezüglichkeit (Reflexion) in der Form, dass ein Programm dieser Sprache Zugriff auf seine eigene Repräsentation hat.

Eine interpretierte Programmiersprache, wie zum Beispiel Perl oder Python, hätte es prinzipiell leichter, da man die vom Interpreter benötigte Repräsentation des auszuführenden Programms auch dem selbigen verfügbar machen könnte, aber in der Regel wird das nicht unterstützt, zum Beispiel aus Sicherheitsgründen, oder weil die Designer der Sprache nicht so weit gehen wollten (zum Beispiel weil selbstmodifizierender Code abgelehnt wird). Meist ist dem Programm dort nicht viel mehr Reflexion möglich, als seinen Namen und die Namen seiner Variablen und Funktionen vom Laufzeitsystem zu erfahren.

Reflexion führt daher in den meisten Programmiersprachen nicht zu einem korrekten Quine.

Code als Daten[Bearbeiten]

Die meisten Programmiersprachen bieten wenig Hilfe, Programme angemessen intern zu repräsentieren und mit diesen Repräsentationen zu arbeiten:

  • sie zu analysieren (Parsen),
  • aus vorhandenen Repräsentationen neue Programme zu erzeugen (Komposition) und insbesondere
  • das repräsentierte Programm auszuführen (Applikation).

Ein bekanntes Anwendungsbeispiel wäre ein Funktionsplotter, das ist ein Programm zum Plotten der Graphen beliebiger mathematischer Funktionen.

Mit anderen Worten:

Für Funktionen gibt es in vielen Programmiersprachen keinen angemessenen Datentyp mit entsprechenden Operationen.

In C kann man ein Stück Programmcode in einer Zeichenkette ablegen, man kann aber wenig damit anfangen, denn dieser ist mit den Mitteln von C nur aufwendig zu analysieren und auszuführen. Man muss dann zu komplexen verpointerten Strukturen und externen Bibliotheken greifen.

Ein positives Beispiel wäre LISP, weil hier Programmcode sehr einfach als Liste repräsentiert und manipuliert werden kann.

Quinierung[Bearbeiten]

Die obigen Ausführungen haben die Schwierigkeit aufgeführt, die ein Programm hat, falls es seine eigene Struktur erfragen will. Dennoch muss es auch in C möglich sein, einen Quine zu realisieren (siehe die Ausführungen zur Existenz von Quines im Theorieteil). Dazu wird folgende Technik verwendet:

Wenn man die eigene Struktur nicht erfragen kann, muss man sie von vornherein wissen.

Man entwirft das Programm in zwei Teilen, in einen, den man den Code nennt, und einen, den man die Daten nennt. Die Daten repräsentieren den Code (bzw. seine Textform) und sie sind auf einem algorithmischen Weg vom Code hergeleitet (meistens, indem Anführungszeichen gesetzt wurden, manchmal aber noch auf eine leicht kompliziertere Weise). Der Code benutzt die Daten, um den Code auszugeben (was einfach ist, da die Daten den Code darstellen); dann benutzt er die Daten, um die Daten auszugeben (was möglich ist, da die Daten in einer algorithmischen Transformation besorgt werden).

Wie oben ausgeführt, geht das in einigen Sprachen leichter und in anderen schwieriger, zum Beispiel je nachdem, ob Funktionen first class citizens der Sprache sind, oder nicht.

Im strengen Sinn sollten Quines vom Zeichensatz unabhängig sein, und der Quellcode sollte einschließlich aller Zeilenwechsel exakt wieder ausgegeben werden.

Sprache Beispiel Hinweise
Lisp
((lambda (x)
  (list x (list (quote quote) x)))
 (quote
    (lambda (x)
      (list x (list (quote quote) x)))))
C
char*f="char*f=%c%s%c;main() {printf(f,34,f,34,10);}%c";main() {printf(f,34,f,34,10);}
Nutzt die ASCII-Kodierung des Anführungszeichens
Lua
a="a=%c%s%c;io.write(string.format(a,34,a,34))";io.write(string.format(a,34,a,34))
Nutzt die ASCII-Kodierung des Anführungszeichens
Python 2
a="a=%c%s%c;print a%%(34,a,34)";print a%(34,a,34)
Nutzt die ASCII-Kodierung des Anführungszeichens
Python 3
a="a=%c%s%c;print(a%%(34,a,34))";print(a%(34,a,34))
Nutzt die ASCII-Kodierung des Anführungszeichens
Perl
$a='$a=%c%s%c;printf($a,39,$a,39,10);%c';printf($a,39,$a,39,10);
Nutzt die ASCII-Kodierung des Anführungszeichens
Perl
$r='\'; $_=$r; s/([\\\'\\\\])/\\\\$1/g; print \'$r=\\\'\'.$_.$r;
'; $_=$r; s/([\'\\])/\\$1/g; print '$r=\''.$_.$r;
Vom Zeichensatz unabhängig
Ruby
puts <<2*2,2
puts <<2*2,2
2
Vom Zeichensatz unabhängig
Ruby
eval s=%q(puts"eval s=%q(#{s})")
Vom Zeichensatz unabhängig
C#
using System;class Quine{static string f=
"using System;class Quine{{static string f={1}{0}{1};static void Main(){{Console.Write(f,f,Convert.ToChar(34));}}}}";
static void Main(){Console.Write(f,f,Convert.ToChar(34));}}
Java
public class q{static String s="public class q{1}static String s={3}{0}{3};
public static void main(String[] a){1}System.out.println(java.text.MessageFormat.format(s,s,''{1}'',''{2}'',''{3}''));{2}{2}";
public static void main(String[] a){System.out.println(java.text.MessageFormat.format(s,s,'{','}','"'));}}
Sleep
[{$s = ';print("[{\$s = ".chr(39).$s.chr(39).$s);}]';print("[{\$s = ".chr(39).$s.chr(39).$s);}]
PHP
$vEngu = 96; printf($c = '$vEngu = %s; printf($c = %c%s%c, $vEngu, 39, $c, 39);', $vEngu, 39, $c, 39);
Pascal
const a=';begin write(^#^/^.^3^4^`^!^}#39,a,#39,a)end.';begin write(^#^/^.^3^4^`^!^}#39,a,#39,a)end.
nutzt Escape-Sequenzen
Delphi
program Quine;{$APPTYPE CONSOLE}var x:String=
'program Quine;{$APPTYPE CONSOLE}var x:String=;begin Insert(#39+x+#39,x,46);WriteLn(x);ReadLn;end.';
begin Insert(#39+x+#39,x,46);WriteLn(x);ReadLn;end.
ohne Zeilenumbrüche (wäre sonst zu lang für diese Tabelle)

Theoretischer Hintergrund[Bearbeiten]

Die Existenz von Quines wird theoretisch durch den Rekursionssatz (auch Fixpunktsatz von Kleene genannt) gesichert.

Grob verläuft die Argumentation so:

  • Man kann auf die Eigenschaften von Programmiersprachen durch Ergebnisse der Berechenbarkeitstheorie schließen, welche sehr einfache Modelle von Programmen mathematisch exakt analysiert.
  • Da man alle Programme (genauer: deren endliche Quelltexte) abzählen, also bijektiv auf die natürlichen Zahlen abbilden kann, reicht in dieser Modellwelt die Angabe einer natürlichen Zahl als Repräsentation eines Programms vollkommen aus. Diese Zahl leistet dasselbe wie der Quelltext, nämlich die Auswahl genau der Funktion, die der Semantik des Programms entspricht.
  • Mit dem Fixpunktsatz lässt sich zeigen, dass es ein Programm mit der Nummer q (mit \forall x: \varphi_q(x) = q) gibt, dessen Ausgabe (für alle möglichen Eingaben x) wiederum die Zahl q ist. Somit ist dieses q aus dem obigen Lemma der Berechenbarkeitstheorie genau das Äquivalent eines Programms, welches seine eigene Repräsentation ausgibt – eines Quines.

Die Aussagen aus der Berechenbarkeitstheorie für berechenbare Funktionen lassen sich leicht auf Turingmaschinen und damit letztlich auf beliebige Turing-vollständige Sprachen verallgemeinern.

Quines sind daher nicht nur zufällig das Ergebnis findiger Programmierer, die eine Programmiersprache austricksen, es handelt sich vielmehr um eine fundamentale Eigenschaft Turing-vollständiger Programmiersprachen, dass für sie Quines existieren.

Einzelnachweise[Bearbeiten]

  1. Craig S. Kaplan: The Search For Self-Documenting Code

Siehe auch[Bearbeiten]

Literatur[Bearbeiten]

Weblinks[Bearbeiten]