Eine Analogie zwischen Köch*innen und Computern:

Wenn Du etwas kochst, dann folgst Du (wenn Du wie ich kein Kochgenie bist) meistens einem Kochrezept, um Dir etwas zu Essen zu machen. Ganz ähnlich machen das auch Computer: Wenn Du diese Seite hier ansiehst, dann folgt der Computer vor Dir einem Kochrezept, das ihm sagt, wie er Dir die Informationen, die Du lesen möchtest, abholen und anzeigen soll. Dieses Kochrezept ist die App oder das Programm (oder wenn Du wie ein Politiker klingen willst „der Algorithmus”). Okay, zugegeben es handelt sich dabei nicht um ein einziges Rezept, sondern um einen riesigen Berg von den verschiedensten und kompliziertesten Rezepten, die man zu allem Überfluss noch ziemlich umständlich in Maschinensprache formulieren muss, damit ein doofer Computer versteht, was er tun soll.

Okay, also nochmal kurz: das Programm (der Algorithmus) ist das Rezept für den Koch im Computer. Dieser Koch im Computer ist allerdings ein bisschen doof, denn er versteht nichts von dem, was er tut. Wenn Du oder ich ein Rezept kochen, in dem drin steht, dass wir in unsere Nudelsuppe jetzt noch Plutonium mischen sollen, dann hören wir damit natürlich sofort auf und schmeißen das Rezept in den Müll. Es taugt ja offensichtlich nichts. Das kann der Koch im Computer nicht. Er kann nicht unterscheiden, was ein gutes oder schlechtes Rezept ist, und hält sich streng an jeden einzelnen Schritt. Das heißt, wenn wir die Rezepte unseres Computers nicht überprüfen, mischt er uns Plutonium in die Suppe (oder sofern es sich nicht um einen Kochroboter handelt, eher: sendet er unsere Babyfotos an Facebook).

Wie schaffen wir es also, dass unsere Computer nur die „guten Rezepte” kochen, also nur die Programme ausführen, die in unserem Interesse handeln und uns nicht schaden?

Prinzipiell könnten wir uns ja alle Kochrezepte erst einmal ansehen, bevor wir sie auf unseren Rechner laden. Da gibt es nur zwei riesige Probleme: Erstens sind es viel zu viele Rezepte, die niemand sich ansehen will (und kann) und zweitens sind die auch noch in Maschinensprache geschrieben. Was ist Maschinensprache? Du hast bestimmt schon mal gehört, dass Computer „nur aus Nullen und Einsen bestehen” oder so etwas ähnliches. Auch wenn das natürlich nicht ganz stimmt, so stimmt es in der Hinsicht, dass Maschinensprache eben nur diese beiden Buchstaben hat. Das bedeutet, jedes Wort besteht aus einem zwangsläufig sehr langen Strang von 0 und 1. Wenn ich zum Beispiel hier etwas schreibe wie: „Ich mag Kartoffeln”, dann sieht das für den Computer so aus:

01001001 01100011 01101000 00100000 01101101 01100001 01100111 00100000 01001011 01100001 01110010 01110100 01101111 01100110 01100110 01100101 01101100 01101110

Ziemlich unübersichtlich, was? Naja, wenn man nur zwei Buchstaben zur Auswahl hat, dann werden die Wörter zwangsläufig halt ziemlich lang. Man muss sich nun vorstellen wie lang und unlesbar ein Rezept in Maschinensprache sein muss, wenn eine einfache Anweisung wie „Nudeln 20 Minuten lang in siedend heißem Wasser kochen” schon so aussieht:

01001110 01110101 01100100 01100101 01101100 01101110 00100000 00110010 00110000 00100000 01001101 01101001 01101110 01110101 01110100 01100101 01101110 00100000 01101100 01100001 01101110 01100111 00100000 01101001 01101110 00100000 01110011 01101001 01100101 01100100 01100101 01101110 01100100 00100000 01101000 01100101 01101001 11011111 01100101 01101101 00100000 01010111 01100001 01110011 01110011 01100101 01110010 00100000 01101011 01101111 01100011 01101000 01100101 01101110

Nun frage ich Dich: Kannst Du das als Rezept interpretieren? Nein? Ich auch nicht. Es gibt zwar Verrückte Spezialist*innen, die sich darauf spezialisiert haben genau das lesen zu können, das nennt man dann „Reverse Engineering”, aber nichtsdestotrotz ist das kein Vergnügen, sehr mühsam und dauert ewig (In vielen Jurisdictions sit es noch dazu wegen intellektuellen Eigentums verboten). Deswegen haben sich Menschen schon früh etwas einfallen lassen, was es ein bisschen einfacher macht, Rezepte für Computer zu schreiben; die Programmiersprachen. In einer sehr bekannten Programmiersprache namens Python könnte Nudeln kochen etwa so aussehen:

from pantry import noodles„ „from cupboard import pot“ „import kitchen as k“ „k.stove.cook(object=noodles, duration=1200, temperature=372)

Wenn Du das nun nicht verstehst, schreibe bitte einen wütenden Brief an deine*n Kultusminister*in, warum es in deinem Bundesland keinen gescheiten Informatikunterricht gibt und ihr das nicht gelernt habt. (Für etwas Extragewicht schreibe etwas über Wettbewerbsvorteil, China, Arbeitsplätze und Digitalisierung 4.0.) Aber Du wirst mir zustimmen es sieht etwas weniger nach Zahlenwirrwarr und etwas mehr nach Englisch aus, nicht wahr? Dieser kurze Code-Schnipsel ist der sogenannte Quelltext des Programms, das Dir 20 Minuten lang Nudeln kochen würde, wenn Du einen Kochroboter hättest. Und wenn Du jetzt Python kennst, dann verstehst Du, dass hier kein Plutonium in diesem Rezept vorkommt. Anders sieht das hier aus:

from pantry import noodles from uc_berkeley import plutonium from cupboard import pot import kitchen as k noodles = plutonium k.stove.cook(object=noodles, duration=1200, temperature=372)

Na, ist Dir etwas aufgefallen? Ich bin mir sicher, dass Dir da etwas komisch vorkommt. Wenn nicht, ist auch nicht schlimm, lass es uns gemeinsam ansehen:

from pantry import noodles from uc_berkeley import plutonium # ←- Aha! Plutonium! from cupboard import pot import kitchen as k noodles = plutonium # ←- Hier werden die Nudeln mit Plutonium vertauscht! k.stove.cook(object=noodles, duration=1200, temperature=372)

Selbst wenn Du die verwendete Programmiersprache nicht im Detail kennst, kannst Du den Code einschätzen und auch wenn dieses Beispiel hier ein wenig konstruiert rüber kommt, so greift doch dasselbe Prinzip bei „echtem Code”. Probieren wir nämlich das gleiche nochmal mit dem selben Code jetzt in Maschinensprache:

01010101 00001101 00001101 00001010 00000000 00000000 00000000 00000000 11010110 11100111 01001000 01011111 10111100 00000000 00000000 00000000 11100011 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 00000000 00000000 00000000 01000000 00000000 00000000 00000000 01110011 01000110 00000000 00000000 00000000 01100100 00000000 01100100 00000001 01101100 00000000 01101101 00000001 01011010 00000001 00000001 00000000 01100100 00000000 01100100 00000010 01101100 00000010 01101101 00000011 01011010 00000011 00000001 00000000 01100100 00000000 01100100 00000011 01101100 00000100 01101101 00000101 01011010 00000101 00000001 00000000 01100100 00000000 01100100 00000100 01101100 00000110 01011010 00000111 01100101 00000011 01011010 00000001 01100101 00000111 01101010 00001000 01101010 00001001 01100101 00000001 01100100 00000101 01100100 00000110 01100100 00000111 10001101 00000011 00000001 00000000 01100100 00000100 01010011 00000000 00101001 00001000 11101001 00000000 00000000 00000000 00000000 00101001 00000001 11011010 00000111 01101110 01101111 01101111 01100100 01101100 01100101 01110011 00101001 00000001 11011010 00001001 01110000 01101100 01110101 01110100 01101111 01101110 01101001 01110101 01101101 00101001 00000001 11011010 00000011 01110000 01101111 01110100 01001110 01101001 10110000 00000100 00000000 00000000 01101001 01110100 00000001 00000000 00000000 00101001 00000011 11011010 00000110 01101111 01100010 01101010 01100101 01100011 01110100 01011010 00001000 01100100 01110101 01110010 01100001 01110100 01101001 01101111 01101110 01011010 00001011 01110100 01100101 01101101 01110000 01100101 01110010 01100001 01110100 01110101 01110010 01100101 00101001 00001010 01011010 00000110 01110000 01100001 01101110 01110100 01110010 01111001 01110010 00000010 00000000 00000000 00000000 01011010 00001011 01110101 01100011 01011111 01100010 01100101 01110010 01101011 01100101 01101100 01100101 01111001 01110010 00000011 00000000 00000000 00000000 01011010 00001000 01100011 01110101 01110000 01100010 01101111 01100001 01110010 01100100 01110010 00000100 00000000 00000000 00000000 01011010 00000111 01101011 01101001 01110100 01100011 01101000 01100101 01101110 11011010 00000001 01101011 01011010 00000101 01110011 01110100 01101111 01110110 01100101 01011010 00000100 01100011 01101111 01101111 01101011 10101001 00000000 01110010 00000111 00000000 00000000 00000000 01110010 00000111 00000000 00000000 00000000 11111010 00001000 01100110 01101001 01110011 01101000 01111001 00101110 01110000 01111001 11011010 00001000 00111100 01101101 01101111 01100100 01110101 01101100 01100101 00111110 00000001 00000000 00000000 00000000 01110011 00001010 00000000 00000000 00000000 00001100 00000001 00001100 00000001 00001100 00000001 00001000 00000010 00000100 00000001

Was für ein riesiger Zahlensalat. Und das für ein winziges Programm! Die Chancen, dass Du oder ich hier irgendetwas Sinnvolles drin erkennen stehen ziemlich schlecht, oder was meinst Du? Und jetzt stell Dir den Zahlenberg erstmal für ein „richtiges Programm” vor! Dort könnte drin stehen, dass dein Computer alle deine Kuscheltiere als Geisel nehmen soll, ohne dass Du auch nur die Chance hast es mitzubekommen. Wie findest Du das?

Naja, es wäre doch gut, wenn Du immerhin die Chance hast, zu jedem Programm, das Du benutzen möchtest, das Rezept zu lesen, oder? Bei FOSS ist das genau der Fall. Hier wird der Quelltext (das „Kochrezept” in menschlicher Sprache) immer für alle (mit Internetanschluss) einsehbar veröffentlicht und diese Veröffentlichung als juristische Pflicht in der Lizenz verankert. Bei sogenannter „proprietärer Software”, dem Gegenteil zu FOSS, jedoch nicht. (Und proprietäre Software ist leider oft das einzige, was wir vorgesetzt bekommen. Sei es Windows und Microsoft Office in der Schule oder im Beruf, aber nicht bei der BUNDjugend! Wir haben seit 2018 eine Selbstverpflichtung zum Einsatz Freier Software, siehe dazu mehr weiter unten.)

Bei FOSS ist es ungefähr so wie beim Essen, bei dem ja auch immer draufstehen muss, welche Zutaten verwendet wurden (zum Beispiel Plutonium). Nur ist Software in mancher Hinsicht ein wenig komplizierter als der Hummus auf deinem Frühstücksbrot. Bei Software reicht es nicht aus die Zutaten zu nennen, weil Software geschrieben wird und nicht durch Pürieren im Mixer entsteht. Bei Software muss das genaue Rezept veröffentlicht werden und das ist der Quelltext!

Weißt Du, wie man Weizen anbaut, Kühe melkt oder kennst Dich mit allerlei Ackergerät aus? Wenn Du nicht gerade Landwirt*in bist, dann wahrscheinlich nicht. Ich auch nicht. Trotzdem weiß ich, wenn ich bei Tante Sören um die Ecke mein Essen einkaufe, dass ökologisch erzeugte Lebensmittel wahrscheinlich besser sind als der Konvi-Rest. Genauso ist es mit Open Source Software. Die einfache Frage: „Ist das freie Software?” kann schon viel bewirken, genau wie „Aber ist das denn Bio?“.

Also auch wenn Du und ich, selbst wenn wir gemeinsam versuchen würden, den kompletten Quelltext, der auf unseren Computern läuft zu lesen und zu verstehen, dabei sicher scheitern würden, weil es einfach viel zu viel und kompliziert ist, so ist das nicht schlimm, denn genau da greift das Mehraugenprinzip. Die Offenheit ermöglicht es, dass auch sehr viele Menschen einen Blick darauf werfen können. Es ist wie bei unseren Gesetzen. Die sind meist komisch formuliert und enthalten manchmal krude Bestimmungen, auf die uns aber Expert*innen aufmerksam machen, wenn sie sie entdecken, und sie uns erklären, sodass wir uns selbst darüber weiter informieren und unser eigenes Urteil bilden können. Das ist gerade bei solchen Dingen wichtig, bei denen wir nicht auf einen Blick den Inhalt abschätzen können.

Ein anderer Unterschied zwischen freier und proprietärer Software besteht in der Perspektive de*r Programmier*in. Beim Programmieren ist es ähnlich wie beim Einparken. Der Code muss richtig herum an die richtige Stelle und darf das, was vorher funktioniert hat, nicht kaputt machen. Genau wie ein Auto richtig herum zwischen zwei andere Autos gestellt werden muss, ohne sie kaputt zu machen. Aber dieser Vergleich ist ein bisschen unfair, weil Programmieren meist ein wenig komplexer als Einparken ist. Deshalb passieren dort zwangsläufig öfter vor allem unbeabsichtigte Fehler. Nehmen wir nun einmal an ich mache einen Fehler beim Programmieren, ich tuschiere also die Stoßstange, von dem Auto hinter mir. Wenn mir niemand dabei zusieht (wie bei proprietärer Software) denke ich mir, „Wird schon nicht so schlimm sein. Der Kratzer da, der war doch schon vorher drin”, und gehe fröhlich davon. Wenn mir jetzt aber die komplette Nachbarschaft zusieht (weil ich diesen Code veröffentlichen werde), na, da werde ich doch noch mal genauer hinsehen, ob dieser Kratzer da nicht doch von mir ist, oder?

To Do Nächste Abschnitte:

- Analogie Open Source Saatgut - Nebeneffekte warum freie Software besser ist - Abschnitt FOSS Selbstverpflichtung Buju - Abschnitt Open Source Hardware