7,7,7,7,7,7,7,7- Lass das!

Geplanter Beginn: 18 Uhr
Tatsächlicher Beginn: 23 Uhr
Delay: 5 Stunden

Die vierte Session fionalerntprogrammieren zog sich etwas hin. Genau genommen dauerte es 12 Stunden, bis Erlehmann und Plom wieder meine Wohnung verließen. Aber dem ging ja auch eine Session plomlerntkochen voraus. Wir mussten solche Probleme behandeln wie

• Was soll dieses Gemüse-wiegen, wie geht das und wie bescheiße ich dabei möglichst effizient?
• Warum heißt das Zutschini und nicht Gurke?
• Wo ist das Huhn in meinem Essen? (Kategorienfehler!)
• Was mache ich, wenn mich Öl aus meinem Topf heraus anspritzt? Deeskalieren oder weitermachen?

Am Ende hatten wir auch noch hohen Besuch von den Schrammhardts da, die uns in heikle Gespräche über Magic und Feminismus verwickelten. Wir fühlten uns ordentlich in die Ecke gedrängt und werden sie sicher wählen.

Als sie gingen, um 23 Uhr, fingen wir an, Dinge an meinem Computer zu machen. ZB. diesen nervigen Piepton ausschalten, der mir immer durch Mark und Bein fährt, wenn ich zu oft Backspace drücke. Ich traute mich deswegen kaum noch laut Musik zu hören, aus Angst, dass dieser furchtbare Ton in derselben Lautstärke mich wieder so erschrecken könnte. Das hat mich zwar praktischerweise immer wieder daran erinnert, dass ich gerade im IRC lauere statt zu lernen, aber mit

modprobe -r pcspk

entfernten wir dann trotzdem den Ton. Weil wir es können.

In Kapitel Drei haben wir ja unsere ersten Programme “exit” und “maximum” geschrieben. Zur Erinnerung: Exit kann gar nichts, Maximum kann mir den höchsten Wert einer Zahlenreihe ausgeben. Am Ende des Kapitels stehen ein paar Fragen, die immer alle meine Notizen als wertlos auffliegen lassen.

—————————————das wird jetzt so ne super langweilige Erklärung, wie das Programm funktioniert, also skip das doch einfach oder so————————————–

Zwischen der vorletzten und letzten Session versuchte ich z.B. aus “Maximum” ein “Minimum”-Programm zu machen. Doof weil dafür muss ich ja verstehen, wie das Programm überhaupt funktioniert. Das erfoderte ziemlich viel Willpower, um sich da durchzulesen. Aber so schwer war das gar nicht. Hier:

Das ist ein Teil des Programmes:

start_loop:
cmpl $0, %eax
je loop_exit
incl %edi
movl data_items(,%edi,4), %eax
cmpl %ebx, %eax
jle start_loop

movl %eax, %ebx
jmp start_loop

Das ist die Loop, die Schleife, durch die jeder einzelne Wert meiner Zahlenreihe einmal durch muss. Jeder Wert wird nacheinander als Erstes in das Register (ein temporärer Speicherort) %eax geladen bzw. kopiert. Das Ende meiner Zahlenreihe ist eine Null. Wenn Also die Zahl in %eax einer Null gleicht, was mit cmpl geprüft wird, hat der ganze Spaß ein Ende und das Programm steigt aus der Schleife aus. Wenn das nicht so ist, macht es halt weiter.
Das ist jetzt wie immer eigentlich alles gar nicht so wichtig, auf jeden Fall wird die größte Zahl immer in %ebx abgelegt. Also wird verglichen, ob die aktuell behandelte Zahl in %eax größer ist als die bisher größte in %ebx. Danach steht dort jle. Das steht für “Jump if the second value was less than or equal to the first value”. Wenn die aktuelle Zahl kleiner ist, sagt das Programm “ok, scheiße, dann nochmal ganz von Anfang der Schleife, mit der nächsten Zahl”. Wenn sie aber größer ist, geht es weiter im Text und die Zahl muss natürlich nach %ebx wandern, weil wir dort ja die Größte Zahl speichern. Also setzt sich die größte Zahl natürlich bei jedem cmpl durch, sobald sie in das %ebx-Register geladen ist.
Dass wir sie in %ebx speichern heißt auch, dass wir später auf sie zugreifen können, wenn wir unsere “echo $?” -Nummer abziehen. Das adressiert nämlich die Zahl, die in %ebx steht. Ohwowohwow!
Und der springende Punkt ist eben, dass ich ein paar Stunden gebraucht habe, um zu checken, dass ich “jle” in “jge” (Jump if the second value was greater than or equal to the first value) umschreiben muss, damit am Ende die kleinste Zahl in %ebx steht. Das bedeutet, dass das Programm wieder von vorne anfängt, wenn der aktuell betrachtete Wert größer ist als der zu vergleichende Wert in %ebx (Der am Anfang übrigens Null ist). Und wenn er kleiner ist, geht da Programm weiter und kopiert diesen kleineren Wert nach %ebx, wodurch sich am Ende der kleinste Wert durchgesetzt haben wird. Das wäre natürlich die Null, die ganz am Ende steht.

Ich begann so langsam zu verstehen, dass Menschen, die beruflich programmieren wohl vor allem dafür entschädigt werden, dass sie sich ab und zu sehr lange und sehr stark ärgern müssen.

Die nächste Aufgabe war “Modify the maximum program to use an ending address rather than the number 0 to know when to stop.”
Wir schrieben ziemlich viel Bullshit in den Code rein, um das zu erzielen. Ich kann mich überhaupt nicht mehr daran erinnern, was wir genau machten, ich war sowieso ein bisschen frustriert, weil ich wirklich nicht drauf kam, wie ich das machen soll. Auch wenn wir tatsächlich ein bisschen zusammen daran arbeiteten. Ich warf ab und zu ein “So ein Quatsch” ein, was ja in 90% der Fälle stimmt. Was Plom schrieb kam mir auch wirklich ein bisschen bescheuert vor (er verzehnfachte ungefähr die Länge des Programms), aber es funktionierte! Die Lösung, die ich dann googlete war natürlich etwas eleganter, aber trotzdem verstand ich dadurch etwas besser, was es mit der Lösungsfindung beim Programmieren auf sich hat. Der Einfachheit halber verzichte ich erstmal auf eine Clean Coding Ethik und arbeite…lösungsorientiert.

Und vor allem muss ich mich daran gewöhnen, Dinge 9000 Mal ausprobieren zu müssen und Fehler zu machen… Denn Programmieren lernen heißt auch manchmal einfach Versagen lernen.

Die letzte Aufgabe, die wir zusammen bewältigen wollten, war natürlich ein “Hallo Welt”-Programm zu schreiben. Das lag Plom sehr am Herzen. Und ja, seit ich mich mit Leuten übers Programmieren austausche hör ich auch regelmäßig “Na? Haha. Hast du schon “Hallo Welt” programmiert?”. Und ich dann immer so “Nein, haha, höhö.” Aber ab jetzt antworte ich darauf: “Ja. In Assembler“.
Und Gespräche übers Programmieren werden nie wieder dieselben sein!
Für das Programm “write” musste ich einen anderen System Call verwenden. Die verschiedenen System Calls sind im Buch (ihr habt es doch jetzt alle runtergeladen oder?) im Appendix aufgelistet. Bisher habe ich immer nur den exit- system call verwendet. Der System Call ruft den Kernel an. Das läuft dann ungefähr so ab:
Kernel: Hallo, ja?
Programm: Ah, cool, hey, du, kannst du mal eben das Programm hier schließen?
Kernel: Wie meinen?
Programm: … *rollendeaugen* Orr guck einfach ins %eax, ok? Da steht alles drin.
Kernel: Hä jetzt tick doch nicht so aus!
Programm: …
Kernel: Jetzt sei doch nicht so. Was steht denn in %eax?
“1″. Ah, ok. Ja, sag das doch gleich!
Programm: Arsch. (legt auf)
Kernel: (legt auch auf)

Und das ist noch ein vergleichsweise simpler System Call. Ein anderer System Call veranlasst das Programm etwas in mein Terminal zu schreiben. Dafür braucht es aber schon ein paar mehr Parameter. Z.B. muss dafür auch bestimmt werden, wohin es überhaupt schreibt. Hier mal der Codedings:
  Mit .ascii können wir lustigerweise
hallo Berndo reinschreiben und müssen
nicht mühselig die Hex-Zahlen raussuchen
\n bedeutet “nächste Zeile”, damit das
später schöner aussieht.
Für den System Call “4″, also “write”,
brauchen wir zum einen den file
descriptor der in %ebx gespeichert
wird. Der bestimmt einfach nur, dass in
mein Terminal geschrieben wird und nicht
sonstwo hin. In %eax schreibe ich die Zahl
4. In %ecx muss der Anfang des Daten-
satzes stehen. (Zeile 11)
Bevor ich aber diese ganzen Sache mache
kümmere ich mich erst um das %edx
Register. Da muss die “range” des Daten-
satzes rein. Die ermittle ich, indem ich
den Wert der Adresse am Anfang der Daten
von der Adresse am Ende subtrahiere. Die
Adressen zeigen ja an, in welchem Byte wir
uns “befinden” auf dem Speicher. Es sind
Positionen, die dann natürlich so und so viele Bytes voneinander entfernt sind, da ja die Buchstaben dazwischen gespeichert sind. Die Differenz wäre also die “range” der Zeichen dazwischen. Aber ist eigentlich alles nicht wichtig und so. Mit “int $0×80″ wird einmal der Kernel gerufen, der das alles durchführt. Dann kommt der übliche exit-system-call mit der Nummer eins. Die steht dann in %eax und ersetzt das was vorher drin war. In %ebx ist die Null, die ich wiederum aufrufen kann, wenn ich das mit “echo $?” mache.

Und wenn ich das dann ausführe, sieht das halt so aus:

\o/ !!!!

Wir experimentierten dann noch etwas herum und fügten dem Hexalcode von “Hallo Berndo” z.B. noch ein 7 hinzu.
Das würde dann so aussehen:

data:
 .int 72, 65, 76, 76, 79, 32, 66, 69, 82, 78, 68, 7
dataend:

(ascii wurde durch .int ersetzt)
7 ist witzigerweise eine Bell, die genau denselben beschissenen Ton macht, den wir erst vor ein paar Stunden von meinem Computer, aus meiner Lebensrealität und aus meinem Gedächtnis verbannt hatten. Aus Gründen…
Das erklärte auch, weswegen wir nichts hörten, als wir das Programm ausführten. Also baute erlehmann den Ton wieder ein und schrieb noch ein bisschen was dazu….

data:
 .int 72, 65, 76, 76, 79, 32, 66, 69, 82, 78, 68, 7, 7, ,7 , 7, 7
dataend:

Ja, das klappte dann zum Glück nicht. Aber so einiges klappte an dem Programm nicht. Es war  eigentlich eine ziemliche Quälerei und ein ewiges Austauschen von offensichtlich sehr einfachen Fragen, die ich trotzdem nicht beantworten konnte und meinem Herumgezicke, dass solche Fragen ja nichts bringen würden. Erschwerend kam hinzu, dass es bereits 4 Uhr morgens war. Meine Augenringe hingen gefühlt bis zum Kinn. Irgendwann trank ich aus Verzweiflung eine Verlierer-Tasse Kaffee und brach damit nebenbei meine Fastenzeit. Aber ok. Alles für den Code. Ganz oder gar nicht. Assembler oder html!

Aber nach 100 Fehlern machte ich auch mal was Richtiges. Und am Ende, nach dem Ausdünnen und Verschönern kam das doch eigentlich sehr hübsche Programm da oben dabei raus. Und Plom stolzierte ein bisschen herum und betonte, wie stolz er auf mich sei.
Erlehmann sagte gar nichts, weil wir wieder in den Modus verfallen waren, ihn immer gleich abzuwürgen, wenn er etwas sagen wollte. Wir waren sehr sehr müde. Aber zufrieden!

Am nächsten Tag – also eigentlich waren nur zwei Stunden vergangen aber ich konnte nicht mehr schlafen, ich glaub ich weiß auch wieso- schrieb ich als erstes völlig übermüdet in meinen IRC-Channel, dass ich wach bin. Und dass das doch irgendwie komisch ist. Was ich halt so mache, wenn ich noch nicht richtig denken kann. Und dann drückte ich ein paar mal zu häufig die Backspace-Taste.

_start exit

Die Programmier-Session war in etwa genauso zäh wie mein Lesen. Aber immerhin lernte ich gleich zu Anfang, dass Menschen wie Grace Hopper, mein absolutes Vorbild (als ob) damals noch debuggt haben, als ein bug ein bug war. Ziemlich cool. Wir kamen auf sie wegen irgendeines blöden Artikels, der behauptet, Frauen würde es schwerer fallen, Programmieren zu lernen, weil sie zuviel Angst davor hätten, Fehler zu machen. Provokation-Plom fragte mich das auch schon mehrmals, ob ich nicht auch Angst habe, etwas falsch zu machen. Aber ich denke dann immer nur, dass ich gerne die Skills hätte, um überhaupt irgendetwas falsch zu programmieren.
Bis zu diesem Zeitpunkt hatte ich ja mehr so Commands und sowas gelernt. Hier übrigens meine Tabelle bisher:

Kleiner Exkurs: Das mit dem Witz neben blog.fefe.de war übrigens erlehmanns Idee. Ich hatte Bedenken ob ich das so lustig finden würde -also doch, ich habe hart und herzlich gelacht, aber überlegt ob es nicht trotzdem diskriminierend gegenüber übergewichtigen Leuten wäre. Wir kamen zu dem Schluss, dass die fefe-Witze derart kultiviert und fefe-bezogen wären, dass es ok sei über solche Witze wie “Wo ist fefe? – Keine Ahnung, wirf was in die Luft” zu lachen und sie zu reproduzieren.
Noch ein kleiner Exkurs: Es gibt ein Programm names Fortunes, das dir immer einen Spruch ins Terminal wirft, wenn du es öffnest. Es gibt aber auch ein Paket mit fefe-Zitaten. Wenn ich richtig verstanden habe hat er das selbst geschrieben, was auf eine übergesunde Portion Über-Egozentrismus schließen lässt. Ich kann sicher noch was von ihm lernen.

Zum Programmieren kam ich auch zu spät, weil ich vorher noch im Jüdischen Museum war. Dort nahm ich an einer Führung teil, was sich wie immer als Fehler herausstellte aber immerhin erfuhr ich zwischendurch vom Rechentisch, einem horizontalen Abakus quasi. Und wie viel mehr Awesomeness das arabische Zahlensystem gegenüber dem Römischen hatte. Unter Anderem wegen der Null! Und was wären wir ohne die Null?
Eine einsame Eins ohne Zweisamkeit. Das war auch das erste, was ich plom und erlehmann dann ganz aufgeregt erzählte. Die zweite Sache, die ich genauso aufgeregt erzählte war, dass ich mich tierisch über einen PC aufgeregt habe, den ich zwischendurch benutzen musste. Ein Windows-Diktator wollte mich dazu zwingen, ein Update durchzuführen und ich lehnte immer wieder ab und ALLE 15 MINUTEN fragte er nochmal. Das wär mir bei Linux natürlich nicht passiert. Hier stürzt höchstens mal der Windows-Manager ab, weswegen ich überhaupt auf den PC zurückgreifen musste. Aber auch das war schnell behoben durch die Spezialexperten.

Jedenfalls konzentrierten wir uns dann auf das exit-Programm das ich schon brav samt der ganzen nutzlosen Comments vom Autor eingetippt hatte. Ich konnte es vorher nicht ausführen, weil nirgends stand, dass ich erstmal einen Assembler installieren muss. (apt-get install binutils btw.). Damit war der Befehl as exit.s -o exit.o natürlich hinfällig. Der hätte die source-datei (daher die Endung .s) in eine object-Datei verwandelt. Aber dank binutils ging das ja dann. Wir reduzierten das Programm auf fünf Zeilen und das sah so aus:

   Was es tut, wenn ich es starte ist, dass es sofort wieder aufhört.
Aber darüber hinaus kann ich mit dem Befehl echo $? auch noch
gucken, ob denn alles okeh ist. Wenn ich eine 0 bekomme, passt’s.

Und die bekam ich auch! Danach schrieb ich dann so im Programm rum, dass ich stattdessen eine 42 als Antwort bekam. Hihi…Ihr könnt ja selber einmal schauen, ob ihr rausfindet wie das geht.
Nach einer ziemlich eingehenden Analyse der Befehle schrieb ich das Programm noch einmal aus dem Kopf und wir merzten nach und nach meine Syntaxfehler aus. Das heißt, ich kann jetzt mein erstes eigenes Programm aus dem Kopf schreiben! Solltet ihr also das Bedürfnis verspüren, so ein absolutes Programm in Reinform ohne störende Schörkel und Funktionen zu haben- ich kann das für euch in Assembler programmieren!

Das zweite Programm mit dem angemessenen Namen “maximum” war schon weitaus schwieriger nachzuvollziehen. Es sieht so aus:

Es schickt die Zahlen des Datensatzes durch eine Schleife, die immer wieder zwei Werte vergleicht- einen, der vorher als der höchste registriert war und einen zweiten Wert, nämlich die nächste Zahl im Datensatz. Ist der neue Wert höher, landet er im entsprechendes Register. Das läuft so lange, bis die letzte Zahl verglichen wurde. Die Zahl, die am Ende noch im Register %eax lauert, ist also die höchste Zahl! Und die lasse ich mir wieder mit “echo $?” anzeigen.
Jetzt muss ich nur noch rausfinden, ob es einen simplen use case dafür gibt. Wie ich bspw. einen größeren dynamischen Datensatz einspeise, damit das Programm mehr kann als das, was ich mit einem kurzen Blick auf die… 15 Ziffern auch selber machen kann. In ca. 3 Sek. Aber das kennen wir ja schon.

Die Aneignung des Programms war… naja, schwerfällig. Wir mussten am Ende und nach 6 Stunden die Session auch abbrechen bzw. ich bat darum. Plom war zwar ein bisschen “hmpf”, weil wir das Kapitel nicht abgeschlossen hatten, aber ich war schon mehrmals neben ihm eingenickt, während er mir ausführliche Antworten auf meine Fragen gab. Ich hoffe er hat das nicht gemerkt und wird es nie erfahren! Erlehmann sagte irgendwann schon gar nichts mehr. Er entschuldigte sich später dafür, er dachte nämlich ich sei angepisst und hätte keine Lust mehr. Mir tat es aber eher leid, dass wir jeden seiner Sätze mit “NEINNEINNEINWARTEPSST” unterbrachen, weil ich erstmal etwas Anderes verstehen musste, bevor er mich mit weiterführendem Wissen verwirrte.

Trotzdem war mir schon bewusst, dass ich zieeeeeemlich viel gelernt hatte an diesem Abend. Und ich wäre sicher mit einem Gefühl der absolute Power of Knowledge aus dem plomspace gegangen hätten wir nicht am Ende die Human CentIpad-Folge von Southpark gesehen. Meine Güte war die furchtbar.

However. Ich hoffe, dass die Schwierigkeitskurve irgendwann auch mal ein Plateau erreicht und ich alle neuen Informationen so verorten kann, dass ich nicht alles lernen muss sondern nur das Wichtigste. Oder dass ich es schaffe mal ausgeschlafen und unverkatert zu einer Programmiersession zu gehen.

Autodiktaturik

Kapitel 3- Your first programs!

Endlich- das wovon die vielen ungebetenen RatgeberInnen die ganze Zeit in meinen Kommentaren sprechen. Produktiv sein, Programme schreiben, sich den Computer Untertan machen und ihn dich alarmieren lassen, wenn die oder der online ist, ihn dazu zwingen, schwierige Rechnungen auszuführen und deine Zeitung reinzuholen.

Nur, dass ein Produktivitätsgefühl wie beim Fertigen eines Produkts mit klarer Kontur keinesfalls eintritt, wenn ich mich Zeile für Zeile durch ein exit-Programm quäle und versuche es zu verstehen. Es ist sicher der unbequemere Weg. Bei Codeyear zB habe ich schon in den ersten Schritten einen Alert programmiert. Er sagt “Deine Mutter” und taucht auf meinem Bildschirm in einem gesonderten Fenster auf, dunkelt alles andere ab und startet, wenn ich nach dem Befehl “Enter” drücke. Aber ich kann mich nicht an den Befehl erinnern und weiß auch nicht, wie der dorthin kommt und was alles passieren muss, damit mein Druck auf die Entertaste meine Flüssigkristalle beeinflusst (Also die des Monitors).

Anders bei meinem ersten Programm, das an Glanzlosigkeit kaum zu unterbieten ist. Es heißt exit und wenn ich es ausführe macht es exit. Seid nett zu ihm.
Aber bevor ich das Programm irgendwann auswendig eintippen konnte muss ich es erst aus dem Buch abschreiben. Hinterher wird im Kapitel jede einzelne Zeile erklärt und die commands werden detailliert beschrieben.  Aber leider ging mir schon nach ein paar Seiten das Durchhaltevermögen aus. Zu schwer! Ich verstand es einfach nicht. Ich machte Notizen, ich markierte, ich lernte Vokabeln, kaufte Blumen. Alles hoffnungslos. Am drauffolgenden Tag ging es ein bisschen besser voran, ich schaffte aber wieder nur ein paar Seiten. Aber die Verzweiflung hielt sich trotzdessen in Grenzen.
Schließlich bin ich nicht in einer Uni eingeschrieben um dort Informatik zu lernen und muss mich Woche für Woche darum bemühen, den Anschluss nicht zu verlieren. Alles was ich tun muss, ist durchhalten.

Anstrengend war es trotzdem. Bisher kann ich noch nicht einschätzen, welche Informationen ich nicht zu verinnerlichen brauche und welche wichtig und weiterführend sind. Ist es z.B. wesentlich, zu verstehen, was ein label ist oder ein system call?
Ich bin zwar auch generell nicht besonders gut im Lesen, also genau genommen habe ich mit jedem Text Probleme, aber noch nie bin ich an einem Text gescheitert. Irgendwie habe ich dann doch meine kognitiven Grenzen erforschen, übertreten und auch ausweiten können. In diesem Falle fühlte ich mich nach 6 Stunden ein wenig wie von einem großen Datenbus überfahren (herrgottja!).

Es war insofern sehr tröstlich zu wissen, dass ich bestimmen kann, in welchem Tempo wir vorankommen wollen und wie schnell wir uns durch das Buch arbeiten werden. Und Nachsicht kann ich auch ausnahmsweise mal walten lassen. Immerhin ist wirklich alles neu für mich. Wenn ich einen Text über die Problematik des Kulturbegriffs lese kann ich mich auf das ein oder andere beziehen und Wissenslücken selbstständig schließen. Hier bleiben sie aber erstmal bestehen. Die Betonung liegt auf Erstmal! Kein Grund also, frustriert zu sein oder Rückschlüsse auf die eigene Technik-Affinität/Blödheit zu ziehen.

Sollte es also tatsächlich Menschen geben, die mich beim Programmieren begleiten und nicht nur Nerds mit Hang zur Nostalgie, kann ich euch nur Mut zusprechen. Solche Barrieren lösen sich mit ziemlich großer Sicherheit auf, wenn ihr ein paar Spezialexperten konsultiert. Auch wenn das nicht weniger anstrengend war. Aber es eröffnete Möglichkeiten.

 

high 31!

So belastend, nervenzehrend, zeitraubend und desozialisierend das Programmieren mit Bernd auch sein mag- es ist schon ein tolles Gefühl, jedem, der es nicht hören will und mit dem man sich gerade über etwas ganz Anderes unterhalten hat solche Sätze wie “Ich kann jetzt mit zwei Händen bis 1023 zählen!” entgegenzuschmettern. Und sich damit ins nerdige Abseits zu katapultieren.

Aber in diesem Abseits lauere ich ja nicht alleine. Im Gegenteil, ich habe seit dem Start des Projektes “Ich lerne etwas Nutzloses (Assembler) weil ich es kann” schon etliche Unterhaltungen mit Freunden geführt, die von Themen handeln, deren Namen ich vor einer Woche nicht einmal aussprechen konnte. Und das mit einer unheimlichen Begeisterung. Hier meine ich mit “unheimlich” wirklich “unheimlich”.

Meine gefühlte Feuertaufe fand aber statt, als ich schniefend und keuchend den kompletten Namen eines Programms im Terminal eingab, um es zu starten. Aber anstatt mich auszulachen, zeigten mir erlehmann und Plom, dass ich im Terminal ja Tab Completion benutzen kann! Ich muss wohl irgendein Geräusch gemacht haben, weswegen Plom meinte, dass dies mein erster Nerdgasm gewesen ist.

Ich war hin und weg! Und dann erst Irssi. Ein IRC-Client ohne wenn und aber. Schlicht, Radikal, so schön! Völlig nutzlos, aber die pure Emanzipation von Buttons und Cursor. Nicht dass ich ein Interesse daran hätte, ihn weiter zu benutzen, aber wenn mal jemand auf meinen Monitor guckt, weiß ich wie ich schnell Eindruck schinden kann.

Aber Schluss mit den Befindlichkeiten. Nachdem wir ein paar Kinderkrankheiten meines Linux zu kurieren versuchten und wenn ich mich richtig erinnere scheiterten, wandten wir uns den harten Fakten von “Programming from the Ground up” zu. Äh ich meinte harte Daten. Nein, Informationen, nein Bytes, äh Bits, nee Moment, NULLEN UND EINSEN!

Genau. Ich kann jetzt in Binärcode zählen dabei weiß ich nichtmal, ob dieser Satz so hinhaut und man das so sagen kann. Aber dieses “NullenundEinsen” von dem immer alle reden ist jetzt endlich Teil meiner kongenialen Identitätsressourcen.
In wirklich sehr zäher Kleinstarbeit versuchten Plom und Erlehmann mir beizubringen, endlich mal vernünftig zu zählen. Es ist ganz einfach.  Ein Finger stellt immer eine Potenz zur Basis 2 dar. Aber selbst diese Formulierung musste ich gerade googlen. Ich konnte das alles zwar schon mehrmals besoffen in unserer Küche irgendwelchen Gästen erklären (an die, die es betrifft, es tut mir leid!), aber so schriftlich und mit lauter ComputerSpezialExperten und meiner Mutter, die mitlesen, fällt es mir doch schwer, eine lückenlose Definition vom Gelernten aufzuschreiben. Ist ja auch egal.

Viel interessanter ist der Fetch-Execute-Cycle, der beschreibt, wie die CPU funktioniert (ohgottwardasjetztschonwiederfalsch?!). Wir haben sogar ein Bild davon gemalt. Links die CPU mit ihren Registern, die über einen Datenbus ein Datum aus Memory Land (rechts, da mit den Bergen) holt. Der Program Counter hält die Adresse bereit und sagt, wo die Information liegt, wenn sie nicht in einem Register direkt bei der CPU gespeichert ist. Diese Information “xxxx” -einmal gefunden- wandert in Richtung CPU. Allerdings passiert sie vorher zB den Instruction Pointer, der als Indikator für Daten, die eine Instruction sind, fungiert. Zurück bei der CPU wird die Information von der ALU (Arithmetic and Logic Unit) verarbeitet und zurück nach Memory Land geschickt. Auf dem Rückweg passiert “xxxx” aber noch einmal den Program Counter, der irgendwas +1 macht, damit “xxxx” nicht auf ein Neues durch den Cycle läuft sondern ein neuer Prozess stattfinden kann. So weit so dilettantisch. Hier, falls überhaupt noch jemand mitliest, die Visualisierung des Ganzen:

Das heißt im Endeffekt, dass ich immer noch nicht weiß, was Assembler ist, und immer noch keine iOS-App gebaut habe. Aber ich habe wirklich, wirklich, wirklich den Eindruck, ein um Längen besseres Verständnis dafür zu haben, wie ein Computer funktioniert. jaja, auch wenn ihr da jetzt sicher anderer Meinung seid.
Ich hab sogar verstanden, wie die Informationen gespeichert sind und was ein Offset ist. Am nächsten Tag sagte jemand -und ich kann leider nicht rekonstruieren, weswegen dieser Jemand das sagte- 7+x und ich dachte sofort an Indexe und Memory Storage und an die Adresse von einem Byte in einem Datenset. Das war schon nicht schlecht.

Den Tag darauf und den heutigen und den morgigen muss ich dann leider damit verbringen, die Scherben von fionalerntprogrammieren zu beseitigen und mich endlich mal wieder um meine Uni zu kümmern. Aber wenn Programmierenlernen zu meiner Prokrastinations-Agenda gehört, kann ich damit leben…Studieren sollte mich schließlich nicht vom Lernen abhalten

Achja.

Unter uns – ich glaube, ich habe die Nacht darauf irgendwas mit Code geträumt.

 

 

 Nachtrag: Oh mist. http://en.wikipedia.org/wiki/Instruction_pointer
The program counter (PC), commonly called the instruction pointer (IP)

Also gut, Bernadettes und Bernds, rangiert was das Zeug hält!

256 million PO Boxes

…bzw. 256 million fixed-size storage locations.
Erstes Kapitel hinter mir und ich bin bereits betrunken und habe den Ich-Werde-Niemals-Die-Beste-Assembler-Programmiererin-Der-Welt-Blues.

Aber immerhin kann ich jetzt das:

72, 69, 76, 76, 79, 32, 66, 69, 82, 78, 68

und weiß ungefähr was da gerade passiert ist zwischen Taste drücken und dem Erscheinen der Zahl auf meinem Bildschirm.

Ich kann das Wort “fetch-execute-cycle” in den Raum werfen und für allgemeine Verwirrung sorgen und ich kann mir in Zukunft vielleicht Witze mit “Data Bus” einfallen lassen. Oder vielleicht gibt es schon irgendwo ein lustiges Bildmakro dazu das ich dann auch verstehe.

Es hakt allerdings hier und da noch. Vor noch einer Woche hätte ich in einem Satz beschreiben können, was ein Byte ist. Naja…jetzt fällt mir das nicht mehr so leicht. Eigentlich weiß ich gar nicht mehr, was ein Byte ist.

Aber die restlichen Fragen werden sich hoffentlich am Donnerstag klären. Ich habe mir fest vorgenommen, alles soweit zu verstehen, dass ich untrollierbare Definitionen von Kernel, CPU, Byte und register geben kann.

Hier ein paar heitere Fragen vom Ende des ersten Kapitels:

• How does a computer know how to interpret a given byte or set of bytes of memory?
• If a machine instruction has to contain a command, two source memory locations, and a destination memory location, how many bytes long does it have to be at a minimum?
• What is a register? How would computation be more difficult without registers?

Hier nochmal der Link zum Buch, das man dort auch runterladen kann.

Jetzt, so kurz vor halb 12 sollte ich dann vielleicht mal mit den Hausaufgaben für die Uni morgen anfangen. Das nächste Update folgt am Freitag.
Euch eine gute Nacht, ihr N00bs.

wir machen jetzt erstmal deinen Rechner platt

“Hast du wirklich alles gebackupt?”
ist nicht unbedingt etwas, was man gerne von zwei Nerdfreunden hört. Aber ich habe mich ja freiwillig in diese missliche Lage begeben.
“Sag Tschüss zu Windows!” sagt plom auf seine erlehmannige Art bevor wir ein letztes Mal meinen PC vor seiner Schönheits-OP herunterfahren. Es ist wirklich ein seltsames Gefühl. Der Computer ist eben doch ein Zuhause, das ich ungern verlasse, wenn ich weiß, dass es später eine komplett andere Inneneinrichtung haben wird.

Aber bevor wir überhaupt meinen PC töteten, lasen wir uns ersteinmal zwei Vorwörter durch. Zwei, weil wir uns eine halbe Stunde nicht darauf einigen konnten, ob nun Assembly Language Step-by-Step: Programming with Linux (das uns Mitch Altman gab) oder Programming from the Ground Up besser wäre. Wir haben uns dann für Letzteres entschieden, weil es dabei auch nicht darum geht, mich zu einer Assembly-Expertin zu machen sondern mir das Programmieren generell näher zu bringen. Außerdem beginnt es mit “I love programming” und im Vorwort kommt ziemlich häufig das Wort “master” vor. Ich hatte auch beim Vorlesen mehrere Fragen, die im darauffolgenden Absatz beantwortet wurden. Ein sehr gutes Zeichen. Ab jetzt gilt es immer jede Woche ein Kapitel zu lesen. Wer mitmachen will sei hiermit natürlich herzlich eingeladen. Ihr könnt ja dann kommentieren oder sowas.

Danach kümmerten wir uns um die Installation von Debian (ein Linux-Betriebssystem so wie ich es verstanden habe). Das funktionierte dann auch nach drei Anläufen.
Linux zu installieren schien irgendwie nur logisch, so kam es mir zumindest vor. Ich kann doch nicht programmieren lernen und dann Windows XP benutzen. Bzw. Windows benutzen. Mir geht es ja darum, meinen Computer zu verstehen. Dazu gehört auch, endlich mal das Terminal zu verwenden. Und zwar für alles. Alles. Auch wenn es mit einem Klick schneller geht. Aber so ein Terminal sieht ja auch schick aus. Ich fühlte mich dem generischen Hacker mit Chips, Kippe, Sonnenbrille und grünen Ziffern die den schwarzen Bildschirm entlangfahren etwas näher. Und damit meinem Ziel!

Die Installation dauerte eine Weile. Wir guckten einen Ausschnitt von einem Fassbinderfilm und ich schickte SMS rum mit “das dauert noch ne Weile. Komme wahrscheinlich nicht mehr nach”.  Als die Installation fertig war sah ich nun das neue Interface meines Computers. Gleich ein Hintergrund mit Raketen und Sternschnuppen, das fand ich irgendwie gut. So harmlos!
Plom und erle zeigten mir das Terminal, wo ich als erstes “man man” eingab. Das kenne ich noch von irgendwann von irgendwem. Dann schauten wir uns ein wenig in den Verzeichnissen um und dann brachten sie mir bei, wie ich Dinge installiere (“apt-cache search” und “apt-get install”) und wie ich mich als root einlogge (“su”) und vor allem wie ich rausfinde, ob ich gerade root bin (“whoami”). Wenn ich root bin, sollte ich nicht gleichzeitig depressiv und/oder alkoholisiert sein. Das habe ich auch gelernt.

Als wir mit dem Internet oder wie das heißt rumexperimentierten, wollte erlehmann den Keyring deaktivieren (damit muss man sich immer doppelt authentifizieren, wenn man ins W-Lan will). Das führte aber dazu, dass ich mich stattdessen beim Neustart nicht mehr authentifizieren konnte, weil die Meldung “authentification failed” immer im Weg war. Das heißt ich konnte nicht mal mehr auf meinen Computer zugreifen! NÄÄÄÄÄÄT Falsch.
Natürlich kann ich das, nämlich mit meinem Terminal, das ich auch aufrufen kann, wenn ich das nicht vorher irgendwo im Bildschirm anklicke. Darüber kommentierten wir den Befehl, der das Unglück verursachte, wieder raus. Faszinierend! Als wäre ich eine Pathologie-Studentin, die das erste Mal…na egal.

Sie zeigten mir noch ein paar awesome features auf meinem Linux, die mein Leben für immer verändern würden. Und sie versuchten mich darauf zu trimmen, in Zukunft nur noch die Thinkpad-Klitoris zu verwenden. Das hat nicht ganz geklappt. Außerdem lernte ich was ein Kernel ist. Bzw. naja, ich würde jetzt gerne wiedergeben, was ich gelernt habe, aber ich müsste das doch nochmal nachlesen. Note to self: Beim nächsten Mal Notizen machen. Gerade habe ich diese Grafik gefunden, die ist ganz nett.

6 Stunden, ein Gericht vom Asiaten, eine Tafel Schokolade, zwei riesige Schokoladenweihnachtsmänner, eine 2-Liter-Flasche Fanta und ein Clementinennetz später (plom: hier, meine Mutter gab mir diesen Sack…Fruchthoden), klappte ich den Laptop zu und ging nach Hause. Wir verabredeten uns zum nächsten Termin am Donnerstag.
Am Tag darauf machte ich für newthinking Fotos und blieb noch anschließend zum Neujahrsempfang wo viele viele Menschen waren. Danach ging ich sogar noch mit ein paar Leuten was essen und trinken. Und auch wenn das sehr schön war dachte ich um ehrlich zu sein die ganze Zeit: “Oh man, diese Menschen überall! Ich will nach Hause, zu meinem Komputah, und mit ihm rumspielen!”

Learn ALL the programming!

“Lerne Programmieren” – das hat mir plomlompom seit ich ihn kenne bereits mehrmals gesagt und -Uncle Sam Style- den Finger dabei auf mich gerichtet. Mit so einem Argument konnte er sehr erfolgreich jede langwierige Diskussion über Gefühle der Unproduktvität oder des Stagnierens beenden. Und erlehmann pflichtete ihm dann sehr überzeugend bei. Kein Zufall also, dass die Beiden jetzt die umfangreiche Aufgabe, mir das Programmieren beizubringen, übernommen haben.

Ich glaube, sie versuchen damit die Welt zu verbessern.

Und gewissermaßen tun sie das. Denn jede Person, die sich die Fähigkeit zur Dekodierung von Code aneignet, lernt, an einem Diskurs teilzunehmen, der einen mittlerweile kaum noch zu übersehenden Einfluss auf unseren Alltag genommen hat.

“Programmieren ist das neue Latein” sagte ein Teilnehmer der Spackeriade im Dezember letzen Jahres. Zwar haben die meisten, denen ich davon erzählte, und die entweder programmieren oder Latein oder Beides konnten, mir immer irgendwie wiedersprochen, aber für mich ist die Sache eindeutig (und die Argumente dagegen habe ich äh vergessen).
Die akademische und klerikale Intelligenz der europäischen Gesellschaft äußerte sich dazu mal auf Latein und verschloß sich damit der Mehrheit- und derjenigen, die nicht Lesen konnten sowieso. Heute, so scheint es mir, bleibt mir ebenfalls ein ganzer Themenkomplex verschlossen, bzw. ich kann ihn höchstens auf einer Meta-Ebene begreifen. Sei es der Bundestrojaner, technische Diskussionen über die Sinnhaftigkeit und Wirksamkeit von Internetsperren oder irgendwelche krassen Hacks von irgendwelchen krassen Hackern. Ich möchte mehr verstehen.

Aber auch auf einer noch alltäglicheren Ebene sehe ich unzählige Vorteile darin, mir das Programmieren anzueignen. Denn damit meine ich natürlich nicht nur, lustige Spiele zu programmieren, die mir mein Studium versauen, sondern auch das Verstehen meines Computers mit dem ich sicherlich mehr Zeit verbringe als mit all meinen Partnern, Freund_innen und Eltern zusammen. Und bei denen bemühe ich mich ja auch permanent darum, ihre Sprache zu verstehen und eine vernünftige Kommunikation zu etablieren.
Wieso nicht dasselbe mit meinem Computer versuchen? Wenn er ein Problem hat, will ich ein offenes Ohr haben. Wenn ich ein Problem habe, möchte ich ihm das auch mitteilen können und eine Lösung finden.
Ich glaube das spart mir viel Ärger. Und irgendwann vermutlich auch Geld.

Zuletzt bekam ich dann über meine Twitter-Timeline von codeyear mit. Eine sehr gute Idee, die es auf eine sehr bequeme Art und Weise ermöglicht, am Ende des Jahres zu den Besten der Besten Programmierer_innen zu gehören! Codeyear war auch ausschlaggebend für meine Entscheidung, den Vorsatz, 2012 Programmieren zu lernen, zu übernehmen.
Simpel wie genial wie bequem wie effektiv. Über den hashtag #codeyear kann ich mich dann einfach austauschen, wenn ich nicht weiterkomme oder fragen, wer bei twitter noch alles nicht die Hausaufgaben gemacht hat.
Codeyear wird dann auch sicher mein Zufluchtsort, wenn ich mal etwas Code-Fastfood brauche. Denn mit plomlompom und erlehmann geht es jetzt erstmal an den Urschleim des Programmierens. An Assembler, eine Maschinensprache, die mir nichts bringt, außer dass ich dann Assembler kann. Aber das find ich cool genug. Die meisten können das nämlich nicht!

Ich freue mich auf viele Wegbegleiter_innen und Facepalmen in den Kommentaren
und natürlich über viele Nachahmer_innen.
Zum Schluss noch ein Ratschlag von Ratschlagfiona, den ihr euch bitte zu Herzen nehmt: