Schlagwort-Archive: asm

Mein Computorbit

Ich hab ein schlechtes Gewissen. Vor zwei Monaten fragte „Gast“:

Hallo,
danke erstmal für dein Blog! Interessant wäre noch zu wissen, wann du zum ersten Mal Kontakt zu Computern hattest (und mit welchem Modell) und in welchem Alter du jetzt zum ersten Mal anfängst zu programmieren. Bei Frauen scheint dies nämlich oft erst wesentlich später als bei Männern zu passieren (warum auch immer).

Und dann schrieb er/sie zwei Tage später

Möchtest du nicht darauf antworten oder hast du nur gerade keine Zeit? Würde mich nämlich wirklich interessieren…
 

Und wiederum zwei Tage später dann las ich in der Zeitung von einem Menschen, namens Gast der erst versuchte sich umzubringen, überlebte und dann einem Circus beitrat, wieder ausstieg und dann ein paar Menschen umlegte. Als Gründe nannte er, dass er Montage nicht mag, einen bescheuerten Vornamen hat und dass Fiona ihm nie antwortete. Seufz.

Also dann. Die Laufbahn meiner Computerisierung, der Orbit from the Ground Up:

Unser erster Computer. Hm. Das war glaube ich ein kleiner Lerncomputer, auf dem es 31 verschiedene Programm gab. Solche Dinge wie Worträtsel, aber wenn ich mich richtig erinnere konnte man darauf auch QBasic lernen. Aber dafür war ich noch viel zu jung, um mir das selber anzueignen. Vermutlich etwas zwischen 6-8 Jahre alt. In derselben Zeit hatten wir einen Amiga. Fick Ja. Einen Amiga. Ein Heimcomputer der -zumindest bei uns- nur für Spiele genutzt wurde. Ich muss immer noch ziemlich jung gewesen sein, auf jeden Fall war ich darauf angewiesen, dass meine zwei Brüder genügend Freunde hatten, mit denen sie die Disketten tauschen konnten. Allerdings verbrachte ich nicht allzu viel Zeit damit, viele Spiele verstand ich noch gar nicht. Ab und zu spielte ich mit einem meiner Brüder North and South oder Rick Dangerous, zu sehr viel mehr war ich gar nicht in der Lage. Und naja. Mit seinem großen Bruder Computer spielen ist irgendwie so erfreulich wie mit einem irren Drogenboss Aufzug zu fahren. Entweder bescheißt er und man verliert oder man verliert nicht und dann wird man gehauen. Oder so ähnlich war das.
Was dann mit dem Amiga passierte weiß ich gar nicht so recht. Ich trau mich auch nicht zu fragen. Vielleicht haben wir zuviel daran prokrastiniert, ihn kaputtgemacht oder uns zu oft gestritten deswegen. Bei insgesamt vier Geschwistern kann das schonmal passieren.

Der nächste Computer hatte ein Windows 95 drauf und den bekamen wir etwa um 98 rum.
Es war eine hässliche Zeit. Es war eine Zeit der kantigen Schrift, des langen Wartens und des lauten Lüfters. Und dann erlöste uns das Millenium mit einem lauten Knall und Zack! war das Internet da. Wir alle versammelten uns um den Computer herum, um dieses Internet auszuprobieren. Und natürlich fällt meinem ältesten Bruder nichts Besseres ein als diese Seite aufzurufen. Was meinen Vater relativ schnell dazu veranlasste, das Internet wieder „auszumachen“. Kostete ja schließlich Geld.

Die nächsten Jahre waren angeblich ziemlich ereignisreich. Terror und so. Ich weiß aber nix davon, ich war im Internet. Spätestens die Flatrate läutete die Epoche der Internet-Sozialisierung in meinem Leben ein.  Allerdings bin ich froh, dass ich so früh schon im Internet verloren ging. Ich habe mich so etwas wie ausgetobt und mittlerweile doch das Gefühl eine Souveränität gegenüber den Verlockungen des Internets entwickelt zu haben. Und nebenbei zogen wir noch auf einen Mac Mini um den meine Eltern immer noch benutzen.

Darauf folgte ein eigener Laptop den ich irgendwo in Deutschland verlor und jetzt habe ich ein IBM Thinkpad mit Linux. 🙂

Soweit zu meiner Computergenese.  Zwar waren Computer und das Internet schon lange ein essentieller Bestandteil meines Lebens. Aber natürlich ist das was ich jetzt tue ein Schritt in ein ganz anderes Nutzer/Maschinen-Verhältnis als es bisher war.
Computer waren für mich fertige Produkte mit einer Palette an angebotenen Möglichkeiten. Sie waren keine dynamischen Werkzeuge, die ich meinen Bedürfnissen anpasse .
Aber das Umdenken ist auch kein plötzlicher Einschnitt gewesen sondern bahnte sich langsam an.

Ich hatte in der Schule mal ITG aber auch nur ein Halbjahr und scheiterte ziemlich daran. Das muss 2002 gewesen sein, als ich 12 war. Ich fand den Unterricht unheimlich langweilig und musste mir tausend Mal die Anleitung anhören, wie ich jetzt ein gif zwischenspeichere und dann irgendwo reinkopiere bis ich es verstand und dann nie wieder brauchte.
Aber das änderte sich bald. Als wir den Mac bekamen war ich schon neugierig darauf, wie er funktionierte. Alleine dadurch, dass ich so furchtbar viel Zeit mit dem Computer verbrachte führte dazu, dass ich ihn nach und nach besser verstand.
Mit 16 hatte ich dann einen Freund, den ich (haha) im Internet kennenlernte. Er ist ein ziemlicher Technik-Freak und wenn ich ihn besuchte konnte ich immer ein bisschen auf seinem Laptop zuschauen. Er benutze Linux und ich bekam einen kleinen Einblick in flexible Nutzeroberflächen, Konsolen und Open Software.
Ich lernte meinen Mac immer besser kennen und als ich mal für ein halbes Jahr in Montana wohnte wurde ich sogar ab und zu dafür bezahlt, Leuten, die Probleme mit ihrem Mac haben etwas zu unterstützen. Allerdings war das Support auf einem…sagen wir niedrigen Level. In etwa so

– „Howdy! Ya know, I wanted t’write that text for mah grandchild and now it’s like jibbedigone ’n I dunno where the redneckhell did ah put it?“
– „I see. Apparently you minimized the window. So um let’s maximize it again. Well. There you go.“
– „Awesome!“
– „Yeah u know, it’s peanuts. Nothing big really“
– „Here, take yer 20 bucks!“
– „Oh.“

Die nächste Station auf dieser Laufbahn tangierte meine Fotografinnendasein. Unser Unternehmen hatte eine Homepage und ich war gezwungen mir ein wenig davon anzueignen. Dafür lernte ich ein wenig html und php um Galerien anzulegen. Und es machte tatsächlich auch ein bisschen Spaß, auch wenn ich nicht wirklich kreativ dabei sein konnte, sondern Code immer nur umschrieb.
Zu der Zeit fiel mir auch auf, dass ich in vielen Freundeskreisen die Einzige war, die überhaupt wusste was ein Quelltext ist. Naja. Natürlich bis ich in die Glitzerwelt der Nerds eintrat und Plom 2010 kennenlernte. Genau genommen hab ich ihn schon ein Jahr vorher auf einer Party kennengelernt und angepöbelt. Auf einem Panel traf ich ihn wieder und seine ganzen verrückten Nerdfreund ebenfalls. Der Beginn einer Freundschaft mit einem IRC-Chatkollektiv!

Und ja, der Rest ist ja bekannt. Seit ich die Nerds (also das Umfeld um Plom herum) kenne erstreckt sich vor mir ein Universum, dessen Grenzen weit außerhalb meiner Sichtweite liegen. Jedesmal wenn sie über ein Thema -sei es aus der Netzpolitik oder über schlechte Internetseiten (z.B. meine alte Fotografinnenseite) oder über Prozessoren- reden wird mir bewusst, was ich alles noch nicht weiß. Und nicht nur das, ich kann auch den Bezug zu meiner Lebensrealität herstellen. Nicht nur weil die Schnittmengen zwischen meinen Interessengebieten und denen der Spezialexpertenprogrammierern sowieso immer größer werden sondern auch weil ich verstehe, dass es für (bisherige) Nichtprogrammierer ebenfalls an Bedeutung gewinnt. Themen wie Bundestrojaner, Möglichkeiten der Technik und Digitalisierung der Gesellschaft gehen eben alle an.

Und deswegen habe ich mit 21 Jahren angefangen Programmieren zu lernen 🙂

Advertisements
Getaggt mit

Counting like a Booliot

Die Sonne scheint, es ist Feiertag, ich bin zu Besuch bei meinen Eltern, sitze in ihrem Garten, bald gibt es Abendessen und ein großartiger Sommer kündigt sich an.
Menschen gehen raus zum Tanzen, umarmen sich, ob Freund ob Feind,  selbst Hund und Postbote, Lantzschi und Erlehmann, Julis und Anti-Deutsche, egal, alles lacht und singt!

Auch: (Bzw. Denn): Wir haben Assembler durch.

Das letzte Kapitel, das wir uns vornahmen handelte vom „Counting like a Computer“. Also von Binärcode, Hexadezimalcode und dem andern da.
Das Vergnügen, Binärcode nicht zu lernen hatte ich ja bereits am Anfang des Kurses. Nach den letzten zwei Programmiersessions verstehe ich alle drei Zählweisen nicht wirklich, aber immerhin besser als gar nicht zu wissen, was los ist, wenn zwei generische Hacker sich gegenübersitzen und hochkonzentriert mit ihren Fingern zählen.

Spannender (und damit meine ich lediglich eine Stufe über „ziemlich langweilig“)  war das mit der Booleschen Logik. Oder besser gesagt die Boolesche Algebra, die mit den Operationen And, Or, Not und Xor funktioniert. Dabei spielen nur zwei Aussagen eine Rolle, nämlich „1 und 0“ bzw. „wahr und falsch“ oder  „An und Aus“.

Jetzt kann man z.B. mit zwei Bytes, die 8 Bits haben so eine Operation ausführen. Bit für Bit wird z.B. „Geandet“. Wenn z.B. die ersten Bits jeweils eine 1 sind, ist das Ergebnis 1. Wenn aber eines der beiden Bits eine 0 ist, ist das Ergebnis 0. Und wenn beide eine 0 sind ist das Ergebnis wiederum 1. Bei Not, Xor und Or sieht das dann natürlich anders aus.

Es gibt aber auch Operationen, die definitiv z.B. aus allen Bits eine Null machen. Wenn ich z.B. das Register %eax mit sich selber XORe, wird aus allen Bits eine Null, da bei XOR alle Bitpaare mit denselben Werten eine Null ausgeben. Und klar. Wenn ich die Bits von %eax mit den Bits von %eax XORe, treffen auf eine Null immer eine Null und auf eine Eins immer Einsen. Uns das Geniale ist, dass ich damit

xorl %eax

quasi das hier gemacht habe:

movl $0, %eax

Nur halt viel schneller 🙂
Und wenn hier jetzt alles falsch ist, weist mich bitte drauf hin, ich hatte nämlich erhebliche Schwierigkeiten damit, das zu verstehen.

Als nächstes sprachen wir über ein Anwendungsgebiet von Oktalcode. Wenn die erhabenen Linuxuser dieser Erde ein ls -l in ihre Konsole tippen kann man die Zugangsberechtigungen zu Dateien, Ordnern etc. sehen.
Ich erinnerte mich auch dunkel an den Open-Syscall zurück der ebenfalls so einen permission Code verlante. Diese Permission Codes sind in den Syscalls in Oktalcode geschrieben, in meiner Konsole sehe ich sie mit dieser Struktur:

-rwxr-xr-x

Die ersten drei Zeichen rwx bedeuten, dass der Owner (meistens root) alles darf. ALLES. Da kennt er nix. Er darf die Datei als Programm ausführen (x), er darf die Datei lesen (r) und er darf die Datei – Fuck Yeah‘ – editieren (w).  Das dürfen die zwei anderen zwei Parteien (group & others) offensichtlich nicht. Da steht nämlich jeweils nur r-x und das w fehlt.

Das kann man aber auch anders ausdrücken!

Zum Beispiel mit einer Zahl. Sagen wir mit der 1337. Okok geht nicht. Dann mit der 0751.

0: Die Null ist ein Indikator dafür, dass jetzt ACHTUNG! eine Oktalzahl kommt.

7: Die 7 ist im Binärcode eine 00000111. Die letzten drei Ziffern sind entscheidend. Eine Eins bedeutet hier „Jajaja, ich stehe für den Buchstaben der hier hin soll!“ Wir haben dreimal eine Eins, was bedeutet dass dreimal ein Buchstabe eingesetzt werden kann, nämlich  „rwx“ . Also bedeutet die 7 am Anfang, dass der Owner alle Rechte hat.

5: Die 5 ist im Binärcode eine 00000101, also ein  astreines r-x, denn für das w fehlt die Eins. Und das bedeutet naaaaaa? Was bedeutet das für die zweite Gruppe?

1: Die 1 ist lediglich eine 00000001 im Binärcode, ein –x also nur. Kann man nix machen.

Und das war’s!
Wir schauten uns dann noch gemeinsam den Code für das Programm in dem Kapitel an, bzw. die gekürzte Version von Plom. Ich hab vergessen was das Programm tut und der Originalcode ist so schlecht, dass ich daraus nichts schließen kann. Aber das macht nix. Es konvertiert halt von einem Zahlensystem ins Andere.
Erst erklärte er mir das Programm und irgendwann übernahm ich und erklärte es mir selbst. Und das war toll. Auch wenn ich mich nie ernsthaft Assemblerprogrammiererin nennen würde (außer zu Trollierungszwecken) kann ich mittlerweile zumindest mit meinem Grundwissen den Zweck eines Programms erknobeln, wenn natürlich auch nur bis zu einem gewissen Punkt. Aber ich habe so etwas wie eine Schwelle überwunden ab der ich mit meinen Kenntnissen selbstständig Neues aneignen kann.
Ich bin schon froh, dass es vorbei ist, aber in einem Gespräch wurde ich letztens darauf aufmerksam gemacht, dass ich vermutlich erst im Laufe der nächsten Lerneinheit, in der wir C lernen, verstehen werde, warum es eine verflucht gute Idee war, mit Assembler anzufangen. Mit derselben Person unterhielt ich mich tatsächlich dann noch ein bisschen über Prozessorarchitektur und Assembler.Aber die Hälfte von dem Ganzen hab ich mit dem ausgenüchterten Alkohol wohl verabschiedet und vergessen. Hm. Hab ich mich überhaupt mit Jemandem darüber unterhalten? Egal. Ah, doch, es gibt Beweise 🙂

———————————————————————————————————————

 

Also dann. Ciao Assembler. Ich denke, die Distanz wird uns gut tun. Und mit meiner neuen, der C-Sprache, glaube ich, werde ich mich selbst und dich in einem neuen Licht sehen. Ich bin stolz darauf, dich zu kennen und bin sehr an unserer gemeinsamen Zeit gewachsen. Dafür danke ich dir.

With U2665

P.S. Aber das Assemblerlehrbuch muss ich zugeben, war ne ziemliche gequirlte Scheiße. Hoffentlich setzt Plom seinen Plan bald in die Tat um und schreibt ein Besseres. Basierend auf meinen Memoiren: „Assembler and I“

Getaggt mit

Hackers: Eine Love- und Sexstory

Als ich Montag letzter Woche aufwachte fühlte ich mich ein wenig wie Bart, als er im Zuckerschock den Pfadfindern beigetreten ist und das erst am nächsten Morgen  bemerkt. Ich hatte mir von Plom am Abend vorher mehrere Bücher für meinen Bücherstack (pushl!) aufschwatzen lassen. Der mittlerweile verdächtig unverändert neben meinem Bett verstaubt. Das liegt unter Anderem daran, dass wir AoM auf meinem Rechner zum Laufen bekommen haben aber das ist eine andere Geschichte. Genau genommen eine Geschichte von verschwendeter Zeit, griechischen Göttern und TK-Pizzen.
Aber mir kam es eigentlich ganz recht, dass ich mich zwischen einem dieser ansprechend gestalteten Büchern entscheiden konnte:

                

Und da „Hackers“ natürlich oben auf meinem Stack lag (das hat mit der spezifischen Architektur meines Regals zu tun) tauschte ich es mit dem Buch von Christian Heller in meinem Rucksack aus und fing an, mich in die Welt der Massachusetts-Brillenträger entführen zu lassen. Und es dauerte eigentlich nichtmal 24 Stunden bis ich schon meinem halben Freundeskreis freundlich aber bestimmt dazu aufforderte das Buch ebenfalls zu lesen. Die Hälfte davon wiederum hatte das eh schon getan.

ES IST SO TOLL UND SIE REDEN VON ASSEMBLER WAS SONST NIE JEMAND TUT!
(immer geht es nur darum, wie scheiße Java ist)

Interessant dabei ist natürlich, dass ich viele der Begriffe und technischen Abhandlungen noch vor einem Monat nur mit Mühe verstanden- nein Moment, gar nicht ver- nein ich wäre nie auf die Idee gekommen dieses Buch zu lesen. Ich hätte Bourdieu unter einem anderen Buch versteckt. Oder unter der Bettdecke. Oder mich unter der Bettdecke. Irgendwie so.

Jedenfalls ist das Buch eine furchtbar nette Ehrung der vielen „awkward“ Nerds vom MIT, die an Computern, in denen ich locker wohnen könnte, das erste „Spacewar!“-Spiel entwickelten. Menschen, für die Computer das interessanteste der Welt waren. Die auch mal auf Schlaf, Schule und Leben verzichteten, um ein Programm zu verbessern. Die im Nachbarzimmer lauerten, um zu sehen, ob nicht jemand seine Schicht am Computer vergessen hatte, damit sie für ein paar Stunden weiter programmieren konnten. Achja und hier sehen Sie Vint Cerf, der das Internet erfunden hat und hier ebenfalls Spacewar spielt:

 

Und das ist der PDP-1 Computer.  In meinem Kreuzberger Zimmer ist Platz
für den Schreibtisch und den Mülleimer.

Aber jetzt auch mal abgesehen von jeder Ironie, mit der ich mich als Nerdette schimpfe, ist es wirklich bemerkenswert, wie sehr sich mir ein komplett neues Interessenfeld öffnet. Ein bisschen so wie ich gehofft hatte. Zuletzt saß ich aus unbekannten Gründen auf dem Boden in der Ecke eines Freundes und guckte auf seinen Tower. Und sah, dass er eine durchsichtige Plexiglaswand hatte! Ich scherzte, dass ich ihn mal irgendwann auseinanderschrauben würde, wenn er ihn nicht mehr bräuchte, aber das durfte ich dann auch so. Das erinnerte mich ein bisschen daran, dass mir mein Vater vor vielen Jahren mal einen kaputten Toaster und einen Schraubenzieher in die Hand gab und ich ihn soweit zerlegen konnte wie möglich. Schon ein wenig absurd, aber zurückblickend ist das aus zwei Gründen lustig: Zum einen, weil das eigentlich ein toller Ansatz ist und ich es jederzeit genauso tun würde. Ich hatte den Toaster auch schon ganz vergessen. Zum Anderen ist das lustig, weil ich den Toaster einen Tag vorher selber kaputt gemacht hatte, weil ich versuchte, ein Toast mit einem Messer herauszufischen bis ein paar Funken aus dem Toaster kamen. Aber das wusste mein Vater ja nicht. Und ich hoffe ihm verrät das jetzt keiner.

In den Tower hineinzuschauen war jedenfalls unheimlich spannend. Das erinnert mich daran, wie mein Vater mir damals sehr oft das Innere von selbstgebauten Raketen zeigte und erklärte und es mich kein Stück interessierte. Aber in diesem Falle war es eine eigene Entdeckung. Ich konnte mir endlich mal ein Bild davon machen, wie eine CPU  aussieht, entdeckte den BIOS chip und fand heraus was das ist. Ich entdeckte ihn auch nur, weil da groß BIOS drauf stand. Ich sah die Arbeitsspeicher, die Festplatte, die Datenbusse und den verstaubten Lüfter, von dem ich Flusen abzupfte. Das machte mich irgendwie nervös und ich reinigte ihn später mit einer Pinzette um mich besser zu fühlen.
Aber abgesehen davon war es tatsächlich weniger ein Blick auf die Computerarchitektur sondern wie eine kleine Reise in das Wissen, das ich in letzter Zeit neu dazugewonnen hatte. Ein bisschen ähnelte das Motherboard einer schwarzen Landkarte, die sich langsam lichtet. So wie wenn ich mit Spähern bei Age of Mythol- na egal.

Es ist ein tolles Gefühl, diese Welt nach und nach zu erschließen. Das zu wollen und zu merken, dass ich dazu fähig bin. Ob mein Vater mir mit dem Toaster sagen wollte „Tochter! Auch du kannst Programmieren, Betten bauen, Autos reparieren und Holz hacken lernen und Spaß daran haben!“ weiß ich nicht. Es hat mir sicher einen kleinen Schubs in die richtige Richtung gegeben. Wobei ich mir schon mehr Ermutigung in diese Richtung gewünscht hätte. Dass ich jetzt eine blumige Geisteswissenschaft studiere ist natürlich in Ordnung. Aber dass schon vorher durch Andere (sexistische Chemielehrer zB.) meine Auswahlmöglichkeiten eingeschränkt wurden lässt sich nicht wegdiskutieren.

Insofern ist es doppelt und dreifach toll, einen Zugang zu etwas so „Technischem“ wie dem Programmieren zu finden. Und festzustellen: Geht ja doch! Auch ohne Dings.

Getaggt mit

Mein Stack, mein Stack, mein Stack

Geplanter Beginn: 20 Uhr
Tatsächlicher Beginn: 22 Uhr
Delay: 2 Stunden

Die letzten Wochen waren sehr hart. Nicht etwa weil ich jeden Tag von Morgens bis Abends für die Uni lernte und am Ende doch die Prüfung versemmelte, sondern weil die Option, das Studium zu schmeißen, Expertenprogrammierin zu werden und ein Buch zu schreiben so viel naheliegender war. So wie alle meine Freunde. Aber ich will ja gar nicht Programmieren, sondern Programmieren lernen. Und meine Freunde sind sie eigentlich auch nicht.
Jedenfalls sei damit die lange Programmierpause erklärt um Spekulationen über Fersagen, Gender und Assembler vorzubeugen.

Es gab wie immer ein recht langes Vorher, während dessen ich Spaghetti für erlehmann kochte die Plom  nichteinmal angucken wollte (wahrscheinlich mischen sich zuviele verschiedenfarbige Bestandteile!). Zwischendurch erzählte Plom uns von seiner Rejection Therapy und wie er jemanden darum bat, 27*111 auszurechnen. Ich tat das zwar unheimlich schnell aber auch unheimlich falsch. Ich sollte mich mehr auf Maschinen verlassen. Und wir versuchten, Spiele auf meinem Linux zu installieren. Dank Wine muss ich nicht mehr Spiele wie OpenTTD spielen, die einen an Kotze erinnern, wenn man die Augen etwas zusammenkneift. Stattdessen hab ich jetzt eine Demoversion von AOE2, die mich bereits in eine mittlere Sinnkrise stürzte, weil ich zum einen nach vier Wochen non-stop-lernen zwei Tage lang das Unproduktivste der Welt tat: AOE spielen- und weil ich die Demo-Kampagne nicht mal mit Level „Medium“ schaffte. Erlehmann war schon vor dem Programmieren aus irgendeinem Grund in meiner Wohnung und versuchte mir OpenTTD zu erklären. Er ließ mehrmals das Wort „Autistenspiel“ fallen und ich sagte irgendwann, er solle ruhig sein, ging ins Bett und schlief auf den Schreck, dass Erlehmann in meiner Küche sitzt erstmal ein paar Stunden.
Jedenfalls wird Wine hoffentlich mein Leben zerstören und jedes einzelne Buch auf meinem Stapel für die Semesterferien mit einem Spiel aus meiner Jugend ersetzen.

Speaking of Stapel – in Kapitel 4 wird ziemlich lange erklärt was es mit dem Stack und der Subtraktion und Addition von Bytes auf den Stapel auf sich hat. Denn wenn der Stapel wächst, schrumpft der Speicher aufgrund der spezifischen Architektur. Irgendwie so halt. Das muss man verstehen um ein Assemblerprogramm zu schreiben, das Parameter einer Gleichung bspw. „auf“ den Stack schiebt. Das fand ich ausnahmsweise sehr leicht verständlich und das liegt vielleicht daran, dass man dieses Denken auch für bestimmte Photoshopoperationen braucht. Allerdings werde ich ja Photoshop nie wieder sehen und mich stattdessen mit der hässlichen kleinen Schwester mit Brille und Zahnspange – Gimp- rumärgern.

Wir beschäftigten uns danach mit dem Aquaplaning des Assemblerprogrammierens: Stack Overflow und Segmentation Fault. Der Stack ist ein Bereich auf meinem Speicher mit dem ich während des Ausführens des Programms arbeite. Ich lege darauf bspw. die Parameter von 111*27 ab. Also 111 und 27. Um diese zu adressieren muss ich dann von der Basis des Stacks so und so viele Bytes herumwandern bis ich bei den Parametern angekommen bin. Wenn ich allerdings zu viele Parameter auf dem Stack ablege kann es sein, dass ich auf den Programmcode stoße, der dann überschrieben wird. Oder ich stoße auf den flüssigen Kern aus Eisen und Nickel. Oder auf einen alten Mann in einer gläsernen Sänfte. Oder auf nen Haufen Socken. Trotzdessen führt das zu einem Abstürzen des Programms und ich werde es bestimmt nie ausprobieren, auch wenn ich noch nicht weiß wie ich das verhindere.

Der Segmentation Fault tritt auf, wenn ich außerhalb des Stacks operiere oder Parameter dort ablege. Folgendes Szenario erklärt das vielleicht ein bisschen besser:
Programm: Wow, ich leg mal ein paar Parameter hier ab.
Kernel: Wir können hier keine Parameter ablegen, das ist Fledermausland!

Das inspirierte uns dazu das schlechteste Programm der Welt zu schreiben. Es heißt
schlecht.s und wir sind sehr stolz darauf. Das Ausführen wirft ein
„Segmentation Fault“ ins Terminal und das wars dann.
Danach schrieben wir aber viel kompliziertere Programme mit
Funktionen und sowas.

Als erstes schrieben wir power.s aus dem Buch ab. Damit kann ich bspw. „(2 to the power of 3) + (4 to the power of 2)“ berechnen. Das sieht erstmal so aus:
Das ist genauso langweilig wie es aussieht, interessant ist die 5. Zeile „call power“ mit welcher die Funktion „power“ weiter unten im Text aufgerufen wird :

Die Funktion arbeitet mit den Argumenten, die vorher mit „pushl“ auf den Stack geschoben worden sind. Der letzte Befehl „ret“ lässt das Programm dann dort weiter machen, wo vorher zur Funktion gesprungen wurde.
So weit so unnötig kompliziert geschrieben. Die nächsten Stunden verbrachten wir damit, power.s zu kürzen. Das Ergebnis kann sich sehen lassen:

So einfach ist das! Anstatt sich schlechten Code anzuschauen, schreiben wir ihn lieber um. Und jetzt muss ich nie wieder selber rechnen.
Übrigens hab ich bei der letzten Session erfahren, dass Plom richtig schlecht in Mathe war und dieselben schwammigen Leistungskurse (Deutsch und Englisch) hatte wie ich. Und später genauso schwammige Wissenschaften studierte. Das fand ich irgendwie gut.  Demnach müsste ich nämlich nur noch 3 Semester studieren, bis ich ebenfalls aussteige und ein Buch schreiben kann. Über das Programmieren oder so.

Getaggt mit

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 $0x80“ 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