Monthly Archives: Januar 2012

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.

Getaggt mit

_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.

Getaggt mit

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.

 

Getaggt mit

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!

Getaggt mit

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.

Getaggt mit
Folgen

Erhalte jeden neuen Beitrag in deinen Posteingang.

Schließe dich 105 Followern an