Monthly Archives: Mai 2012

Compilers are Blood Sugar Sex Magick!

“Und jetzt verstehe ich endlich, was für ausgefuchste Dinger diese Compiler sind! ich meine… wtf, wie unglaublich komplex und so…”

Sagte ich auf der Autofahrt von Berlin nach Hinterspandauland, nach der ersten richtigen C-Session. Und der Fahrer stimmte mir zu und gemeinsam fuhren wir auf dem magischen Regenbogen in Richtung Nirvana, wo alle die hinkommen, die von der Erkenntis ihrer eigenen Bedeutungslosigkeit erleuchtet den Rest ihres Daseins über die hohe Kunst der Compileroptimierung nachdenken.

Natürlich ist das Quatsch. Ich würde nie an einem spirituellen Ort mit Andreas Bogk und Fefe rumhängen.

Der Pfad zu meiner Erleuchtung begann letzte Woche im Lenbachpark. Ich war ziemlich übel gelaunt, es war viel zu warm, ich hatte tausend andere Dinge für die Uni zu tun, ne Menge Herzschmerz und Erlehmann nervte über alle Kanäle die er nicht aus ethischen Gründen ablehnte. Irgendwie sowas wie meine privilegierte Defaultsituation.
Ich war etwas skeptisch bezüglich der bevorstehenden Session. Wir hatten nämlich eigentlich schon eine gehabt, die aber vor allem darauf hinauslief dass wir uns wiederum nur C-Programme in Assemblercode angeschaut haben. Da konnte ich ja noch nicht ahnen, was kompilierter Code mal für mich bedeuten würde. Stattdessen ärgerte ich mich, weil die Hoffnung auf leicht verdauliche assemblerlose Sessions ausblieb.

Plom und ich fanden uns ca. 45 Minuten nach der verabredeten Zeit. Wir waren zwar beide vor Ort allerdings zu faul um einmal um den gerade mal ein halbes Fußballfeld großen Park zu laufen. Stattdessen gingen wir immer wieder mal in den IRC-Chat, motzten rum, weil wir schon ewig warteten, und gingen wieder raus und verpassten uns.
Aber irgendwann schlossen wir uns zusammen und fanden ein sonniges Plätzchen wo wir erstmal versuchten herauszufinden, wie wir mit unseren alten Thinkpadlaptops eine Position finden könnten in der uns sie Sonne nicht am Programmieren hindern würde. Plom stellte fest, dass es am Besten funktioniert, wenn man den Laptopbildschirm auf den Boden legt.
Das Gute am Friedrichshain ist ja, dass merkwürdiges Verhalten entweder als ironische Performance interpretiert oder arroganterweise ignoriert wird. Denn wer Aufmerksamkeit will nimmt mir Aufmerksamkeit weg! Also saßen wir über unsere Laptops gebeugt und hackten das erste Programm ein.
Ein sehr simples aber schönes Temperatur-Konvertierungs-Programm, das Celsius in Fahrenheit umrechnet und in die Standardausgabe schreibt – also ins Terminal.
Das Programm beruht auf einer recht simplen Formel:

celsius = 5 * (fahrenheit-32)  / 9

Das ist soweit verständlich oder? Die dargestellen Rechenoperationen, also Division, Subtraktion und Multiplikation können so als Befehle erkannt werden. So wie es auch jedeR in der Schule gelernt hat. Im Gegensatz natürlich zu Assembler, wo Rechenoperationen durch Registerjonglage und mit speziellen Befehlen dargestellt wurden.

#include <stdio.h>

/* print fahrenheit celsius table */

main ()
{
        int fahr, celsius;
        int lower, upper, step;
        
        lower = 0;      /*lower limit*/
        upper = 300;    /*upper limit*/
        step = 20;      /*step size*/

        fahr = lower;
        while  (fahr <= upper) {
                celsius = 5 * (fahr-32)  / 9;
                printf("%d\t%d\n", fahr, celsius);
                fahr = fahr + step;
        }       
}



Für alle die noch nienienie was mit C zu tun hatten (und nachvollziehbarer Weise meinem Ratschlag, Assembler zu lernen nicht nachgekommen sind) sieht das Programm vermutlich genauso fremd, kryptisch und unästhetisch aus wie jeder andere Code. Aber das vergeht ganz schnell, wenn wir das Programm nach und nach analysieren.
Als erstes gilt es immer zu klären, was das Programm eigentlich für mich tun soll. Wie gesagt.
1. Rechne einen Fahrenheitwert um in Celsius
2. Fang mit dem F-Wert 300 an und ende bei 0°Fahrenheit
3. Mach das automatisch, wenn ich dich aufrufe, und zwar in einer Schleife, die mit Fahr=300 anfängt und dann in 10-er-Schritten runtergeht bis Fahr=0
4. Gib die Ergebnisse in einer Tabelle in meiner Konsole mit der ich den Programmgeist anrief aus
5. Bitte. Danke.

Aber das Programm wäre nicht ein Programm (sondern ein Mensch oder sowas), wenn ich nicht noch ein hübsches Framework um diese Anweisungen bauen müsste.
Die erste Zeile,

#include <stdio.h>

ist eine Anweisung an den Compiler. Sie sagt ihrer studentischen Hilfskraft:
“Hallo Herr Compiler, kannst du mal eben in die große unsichtbare Bibliothek gehen und dieses Buch da, “Standard-Input-Output” in h-form für mich besorgen, durchlesen und für meine Recherchen verfügbar machen? Verlag und so weiß ich jetzt nicht, aber das kriegst du schon hin. Und wenn du schon dabei bist – wenig Milch, viel Zucker, ok? Danke!”
Nächste Zeile:

/* print fahrenheit celsius table */

Ist nichts weiter als ein Kommentar. In Assembler wurden die Kommentare mit eine Raute markiert, was ich persönlich schöner fand. Aber gegen jahrhunderte alte Konventionen kann man so viel machen wie gegen einen Berg.
Was als Kommentar in meinem Programm steht wird nicht ausgeführt und nicht vom Kernel berücksichtigt.
Nunja, eigentlich ist “Ist nichts weiter als ein Kommentar.” eine etwas problematische Formulierung. Ich habe zwar schon darüber geschrieben, aber für die Neuzugänge wäre es durchaus wichtig nocheinmal zu betonen

KOMMENTIERE DEINE PROGRAMME, FOOL

Das hat was mit Solidarität und sozialer Verantwortung zu tun, jawohl.
Und du bist es deinem ICH in ein, zwei oder 30 Jahren schuldig. In den Kommentaren kannst du in einem selber verfassten Text dein Programm erklären und nachvollziehbar machen. Für Andere und für dich. Und da wir natürlich alle unsere Programme offenlegen und teilen, ist das dringend notwendig. Daher empfiehlt sich auch, die Kommentare auf Englisch zu verfassen. Außerdem, kleiner Pro-Tip am Rande: Auch wenn ein Programm schon Kommentare hat, z.B. in einem Lehrbuch, würde ich immer nochmal selber die Kommentare mit eigenen Worten ergänzen oder abändern.

Nächster Punkt:

main ( )
{

Zur Erklärung: Ein C-Programm besteht immer aus Funktionen und Variablen, also Werten. In den Funktionen stecken Statements die eben sagen, was genau für Operationen durchgeführt werden sollen. Main ist so eine Funktion, die in jedem C-Programm auftauchen muss, denn dort beginnt die Ausführung des Programms. Hinter main sind leere Klammern, das heißt, dass keine Argumente vorhanden sind. Das ist aber erstmal nicht wichtig. In den Schnörkelklammerdingern da folgen die Statements.
Die erste Klammer zeigt also an, dass es jetzt losgeht:

        int fahr, celsius;
        int lower, upper, step;

Die ints bedeuten einfach, dass die Werte, die später für “fahr”, “celsius” etc. eingesetzt werden, Integer sind. Also ganze Zahlen, kein Bullshit mit Kommata und Dezimal und so.

        lower = 0;      /*lower limit*/
        upper = 300;    /*upper limit*/    
        step = 20;      /*step size*/

 

Für die Rechnung die gleich unten anfängt werden hier die Werte festgesetzt.
Lower ist der der Wert bis zu dem Fahrenheit runtergeschraubt werden soll. Das heißt der niedrigste Fahrenheitwert der umgerechnet wird ist 0° Fahrenheit. Dasselbe gilt für upper, der höchste Fahrenheitwert der berechnet wird ist 300° Fahrenheit.
Step ist der Wert vom Intervall, also in welchen Schritten wird Fahrenheit runtergesetzt. Wenn 300°Fahrenheit der erste Wert ist, wird als nächstes 280° Fahrenheit berechnet usw. Das kann man dann natürlich beliebig ändern, auch in 1 oder 5 oder 10.

        fahr = lower;
        while  (fahr <= upper) {

 

Und jetzt: Glitzerglitzermagie! Wir fangen an mit Fahrenheit=lower, also bei 0° Fahrenheit. Die nächste Zeile bildet eine Schleife. Sie sagt, solange es wahr ist, dass Fahr kleiner oder genauso groß ist wie upper wird folgende Operation durchgeführt. Also solange der Wert von Fahrenheit den wir umrechnen kleiner oder gleich 300 ist. Wenn er drüber ist, wird die ganze Aktion abgebrochen.

                celsius = 5 * (fahr-32)  / 9;

Hier, die Formel, wie Celsius errechnet werden kann. Hatten wa schon. (Das dauert ja ewig hier : / )

                printf("%d\t%d\n", fahr, celsius);
            

Das sieht hässlicher aus als es ist. Printf ist eine Funktion, die nicht C-Spezifisch ist, und sie ist aus der Standard-Library.  In diesem Falle bewirkt sie eben, dass die Dinger in der Klammer in mein Terminal geschrieben werden.
Besagte Dinger sehen erstmal etwas kryptisch aus aber man kann sie aufteilen in Argumente. Die Zeichen in den Anführungszeichen bilden das erste Argument. Nach jedem Komma folgt ein weiteres Argument.

%d – d ist ein Platzhalter für das respektive zweite Argument, also fahr. “d” weil es sich um einen Dezimalinteger handelt. Es könnte auch stattdessen ein %f dort stehen, für “floating point” um solche Zahlen wie 13.8 darzustellen.
\t   – Backslash t heißt, dass ein tab zwischen den beiden “d”s stehen soll. Also wird ein bisschen Platz gelassen dazwischen.
%d – steht wiederum für einen Wert der geprintet wird, in diesem Fall das dritte Argument, also celsius.
\n – Backslash n heißt, dass eine neue Zeile begonnen wird

Und die Klammer machen wir wieder zu. Es folt:

    fahr = fahr + step;
        }       
}

Das heißt schlauerweise, dass jetzt fahr um 20 erhöhrt wird. Sonst würden wir ja ewig errechnen, wieviel  0°Fahrenheit in Celsius sind. Also ist nach dem ersten Durchgang der Schleife Fahrenheit bei 20°. Und so weiter, nach jedem Durchgang wird Fahrenheit wieder um 20 erhöht… bissssss Fahrenheit bei 300° angekommen ist. Denn, ihr erinnert euch, sobald  Fahrenheit mehr als 300° ist, ist die Bedingung der Schleife ( fahr <= 300) nicht mehr erfüllt und das Programm ist zuende.
Und jetzt noch die Klammern schließen, nochmal schließen…. und fertig!

Damit das Programm aber überhaupt seinen einprogrammierten Nutzen erfüllt, muss es ausgeführt werden.
Für blutige Anfänger: Dafür wird das Programm erst in einen Editor geschrieben. Das mache ich z.B. mit nano. Dafür tippe ich in mein Terminal

 nano tempcalc.c

Es wird eine Datei namens tempcalc.c erstellt und geöffnet und da schreibe ich das Programm rein. Dann sichere ich sie unter diesem Namen und schließe das Programm. In meinem Terminal gebe ich jetzt ein

cc tempcalc.c -o tempcalc

Mit dem Befehl “cc” wird das Programm kompiliert. Mit -o gebe ich den Befehl, dass die neue Datei, die dabei entsteht tempcalc heißen soll. Also genauso nur ohne die .c -Endung

./tempcalc

. / ist der Befehl um Programme auszuführen. Das mach ich auch in meinem Terminal. Und HEUREKAOMFG

0       -17
20      -6
40      4
60      15
80      26
100     37
120     48
140     60
160     71
180     82
200     93
220     104
240     115
260     126
280     137
300     148

Mir ist halt irgendwie auch klar, dass ihr jetzt genausogut diese Seite aufrufen könnt, wenn ihr in die unangenehme Situation kommt, dass euch mal jemand fragt, wieviel 240° Fahrenheit in °Celsius sind. Aber darum geht es ja nicht und so. Wichtiger ist, dass der Programmcode – ich wage zu sagen, anders als bei Assembler, schon jetzt als Schablone für ganz andere Programme dienen kann. Ich kann die Formel auch umändern und die Begriffe “fahr” und “celsius” durch “euro” und “yen”  ersetzen. Oderoderoder.
Ich kann nur empfehlen, das mal nachzuschreiben und dann etwas abzuändern. Dadurch verinnerliche ich zumindest immer am Besten die Funktionsweise.

Bleibt zu sagen: Die Strategie, mit etwas absurd schwerem anzufangen, damit C umso leichter erscheint ist wunderbar aufgegangen.
Wir waren am Ende der Session in eine verrauchte Sporkneipe umgezogen, wo wir misstrauisch beäugt wurden. Ich kann es ihnen nicht verübeln. Ein Nerd und ein Mödchen, die zum Trinken Orangensaft bestellen und auf ihre Laptops einhacken statt Dart zu spielen. Aber das störte uns nicht weiter. Wir waren berauscht von unserem gemeinsamen Erfolg! Wir vergaßen sogar, dass Erlehmann mittlerweile bereits vier Stunden zu spät war. (Am Telefon erklärte er uns noch später, er hätte sich nur kurz hingelegt und würde jetzt los) Stattdessen führte mich Plom noch ein wenig in das altehrwürdige Handwerk der unleserlichen C-Programmierung. Man kann nämlich den kompletten Code auch einfach in einer Zeile schreiben!
Wir schauten uns auch wieder einmal den in Assembler kompilierten Code an. Wo mir dann besagte Erleuchtung kam. Bzw. die trat ein paar Stunden später ein, zu diesem Zeitpunkt war ich zu keiner anstrengenderen Emotion als “binmüde” mehr fähig.

Jedenfalls – auch wenn ich wirklich noch nicht viel von Compilern verstehe – habe ich doch eine Ahnung davon, was für eine wunderbare Welt der Komplexität dahinter steckt.
Ein Programm kann ja nicht eins zu eins übersetzt werden. Dann würde ähnlich sinnvolles Chop Suey wie bei Google Translate dabei entstehen, wenn eine Sprache Wort für Wort in eine andere übersetzt wird. Wenn ich einen deutschen Text ins Englische übersetze muss ich ja etliche Konventionen beachten und inhaltlich trotzdem versuchen dasselbe zu vermitteln. Das könnte ein Programm nicht ohne Weiteres. Aber ein Compiler kriegt das eben doch hin. Der Assemblercode hat Schleifen erkannt und in Assembler übersetzt und alle dafür notwendigen Herumfrickeleien mit den Registern “erdacht”.
Um präziser auszudrücken was mich daran so fasziniert fehlt mir noch das Vokabular. Aber genau für solche Dinge, um das zu erkennen, zu sehen was ein Compiler eigentlich leistet, dafür hat es sich schon gelohnt, Assembler ansatzweise gelernt zu haben. Und das nicht nur zu erkennen, sondern auch maßlos fasziniert zu sein! :)

 

Getaggt mit

“Wir haben jetzt Programmieren”

Seit wir mit Fionalerntprogrammieren begonnen haben, taucht immer wieder die Debatte um das Thema “Programmieren in der Schule auf”, Christorpheus z.B. machte sich auf Googleplus Gedanken darüber welchen gesellschaftlichen Schaden wir davon tragen, dass Programmieren als Kulturpraxis nicht vermittelt wird:

“Immernoch oft denke ich darüber nach wie unglaublich hoch der zukünftige gesellschaftliche Schaden (im Sinne von Selbstbeschneidung) dadurch ist, dass HTML & Co. (bzw. Informatik) noch nicht und wohl auch nicht in absehbarer Zeit als extra Schulfach verpflichtend ab der 5. Klasse eingeführt ist.”

In den bisherigen Diskussionen die ich dazu verfolgt habe scheint es mir, als wäre keineR explizit dagegen, dass Kinder Programmieren lernen, aber die Lager teilen sich auf in solche, die ein entsprechendes Schulfach fordern und jene, die behaupten, dass gerade die Schule den Nutzen des Programmierens nicht vermitteln oder gar den Spaß daran dauerthaft verderben könne.
Wer dagegen wäre müsste auch ziemlich lange nach guten Gründen suchen oder ein nostalgischer Fanatiker der vortechnischen deutschen Volkskultur sein. Also so wie es die ForscherInnen meines Studienfachs bis in die 90er aber ok egal.

Die Notwendigkeit bzw. die Vorteile dabei, Programmieren zu lernen liegen für die meisten vermutlich auf der Hand. Vor allem natürlich für jene, die überhaupt verstehen, was Code ist, wo Code ist und wie man codet.

Code ist ein Werkzeug. Und wie jedes Werkzeug erhält es seine Bedeutung und Wirkung durch die Menschen die es verwenden, um die Anforderungen ihrer Umwelt zu bewältigen. Christorpheus hat also Recht wenn er Programmieren als Kulturtechnik versteht. Hust. Auch wenn ich den Kulturbegriff aus Gründen nicht so gern bediene und der Zusammenhang von Technik und Kultur (ist Technik eine Kultur, ist sie Kultur oder ist sie das Andere?) umstritten ist.
Was zählt ist, dass wir uns mittlerweile eine Welt geschaffen haben in der wir nicht mehr nur so etwas wie ein globales Baukastensystem mit Hammer und Schraube haben sondern auch ein weltumspannendes Gerüst für welches wir Computer und Code als Werkzeuge benötigen. Und natürlich das Wissen, wie wir sie anwenden. Dieses Wissen ermöglicht es mir, die geschaffene Infrastruktur zu verändern, zu verbessern und für mich zu nutzen.
Oder:  Ich kann sie auf mich münzen.
Oder: Ich bin ein böser Schurkenstaat und kann mir diese Kulturtechnik zunutze machen, meine Massen mobilisieren, euch isolieren und ihr werdet alle sterben. Weil ihr nicht coden könnt.

Woist Code? Das ist ja das schöne: Code ist überall. Code ist in der Schreibsoftware und Code macht aus den Notizen der letzten mühseligen Gruppenarbeit ein offenes Dokument das du mit all den faulen Gruppenmitgliedern teilen kannst, die selber nichts erarbeitet haben. Code steckt in dem Emailprogramm, für das du zum Glück nichts bezahlen musst, außer vielleicht mit deinen Daten. Code steckt auch in dem Programm, das meine Emails scannt und die Daten an wer-weiß-wen weitergibt. Code ist auch das was wer-weiß-wer nutzt, um womöglich das Wort “Bombe” oder “Gentrifizierung” aus dem Wust an Daten zu filtern und dann das Ergebnis menschenlesbar zusammenzufassen.

Und wie codet man? Das ist eine Frage. Die Andere ist, welche Bedeutung es hat coden zu können. Das habe ich die letzten zwei Absätze hinreichend erklärt, zumindest aus meiner Sicht. Diese Frage gilt es zu stellen und zu beantworten.
Mittlerweile habe ich in verschiedenen Formaten und mit verschiedenen Blickwinkeln festgestellt, dass die Tragweite der Fähigkeit zu Programmieren sich einem erst erschließt, wenn man schon ein paar Schritte in diese Richtung gegangen ist. Und genau das ist der springende Punkt der mich zurück zum Thema dieses Posts führt. Das Schulfach “Programmieren”.

Dem Verdacht, dass die Institutionalisierung des Lernens bereits das Ende des Lernens ist, liegt eine belastende Beweislage zugrunde. Unsere Erfahrungen z.B. Die gängigen Rückschlüsse aus meinem Versagen in Chemie, Mathematik und Physik vertragen sich kaum mit meiner jetzigen Begeisterung für Technik, Mathematik und Computerarchitektur . Was übrig bleibt ist die Erkenntnis, dass die Schule mein Interesse nicht wecken konnte.
Und wie furchtbar war der Informationstechnische Grundkurs. Zwei Stunden lang gifs kopieren, zwischenspeichern und in ein Dokument einfügen, wenn man eigentlich lieber Minesweeper spielen würde. Ging aber auch nicht, weil wir ja zu zweit am Computer saßen. Einer dümmer als der Andere. Und nach der ITG-Stunde womöglich sogar noch ein bisschen dümmer. Und jetzt alle mal gemeinsam kotzen: Excel. Ich habe mittlerweile kein Problem mit Tabellenkalkulation. Ich kann mir nämlich alles erarbeiten was ich brauche. Und das ist um Welten weniger nervig und ätzend als in einer großen Gruppe im Schneckentempo Formeln einzutippen, sich merken zu müssen und sich so sehr zu langweilen, dass man nichteinmal das auf die Kette bekommt.
Was hab ich gelitten.

Aber das sind noch keine ausreichenden Argumente gegen ein Schulfach “Programmieren” ab der 5. Klasse.

Meine Erfolglosigkeit in bestimmten Schulfächern spricht nicht gegen die Relevanz des vermittelten Inhalts. Ich meine damit den Inhalt den sie mir mit verrosteten Federn oder sehr fragwürdigen alten Transistoren beizubringen versuchten. Meine Erfolglosigkeit spricht gegen die Art und Weise der Vermittlung, sie spricht gegen das Schulsystem, sie spricht gegen Lehrerdinos die nichteinmal in Didaktik und Pädagogik geschult wurden und uns alle hassen.
Die Kritik muss also an der Schule und nicht am Inhalt ansetzen. Und zu glauben, dass die Institution Schule in 10 Jahren noch dieselbe sein wird ignoriert nicht nur die Veränderungen in den letzten 10 Jahren sondern auch die vielen Diskurse die nun endlich entweder wieder oder neu angekurbelt wurden. Wer heute auf Lehramt studiert, so scheint es mir, hält alle LehrerInnen im Amt für unfähig und trägt neue Ansätze in sein Amt hinein. Aber ich bin offen für andere Sichtweisen von Studierenden oder Unterrichtenden. Haltet ihr das für naiv? Sind wir vielleicht doch alle verloren? Dann bitte mit Beleg.

Zum Anderen wäre ein Fach “Programmieren” auch etwas anderes als der Informationstechnische Grundkurs. Es sollte nicht darum gehen, konkret ein einzelnes Programm bedienen zu lernen das in 5 Jahren eh durch ein besseres ersetzt wird. Es geht um Grundlagen. Für solche Zwecke gibt es bspw. die Programmiersprache Logo. Ein Fach wie “Programmieren” kann SchülerInnen dazu ermutigen und befähigen mit ihrer Fantasie und einem Computer Neues zu schaffen. Es kann unheimlich viel Spaß machen. Muss ja auch kein Assembler oder sowas im Lehrplan stehen. Und selbst wenn der oder die SchülerIn nie so richtig Begeisterung dafür entwickeln konnte, wird es trotzdem ein grundsätzliches Verständnis dafür vermitteln können, was dieses Programmieren eigentlich ist. Genauso wie Chemie und Physik, die ich glücklicherweise irgendwann abwählen konnte. In Chemie hatte ich mal eine stolze 5 auf dem Zeugnis, aber das heißt nicht, dass ich nicht trotzdem ab und zu auf vorhandenes Chemiewissen zurückgreifen kann. Ach und Fun-Fact: Plom war ähnlich schlecht in den Naturwissenschaften.

Was ich damit sagen will:
Nicht nur die Tatsache, dass ein Verständnis von Code und Programmieren einem Tor und Tür zu politischer Emanzipation und zu einem effizienterem Umgang mit dem Computer öffnet, spricht für das Schulfach. Pragmatischerweise sei noch erwähnt, dass es einem natürlich auch bessere Chancen auf dem Arbeitsmarkt verspricht und nebenbei spart man ne Menge Geld wenn man beim Website-Erstellen nicht auf Leute wie Plom oder Erlehmann angewiesen ist.
Aber was ich ganz entscheidend finde ist, dass nach dieser Grundausbildung zumindest wüssten was sie eigentlich abwählen, wenn es dazu kommt. Es wird immer schwieriger zu ermessen, welche Dimensionen sich hinter meinem klickbaren Desktop erstrecken.

 

Was ich damit jetzt wirklich sagen will, bzw. tl;dr:
Es liegt m.E. in der Verantwortung unserer Bildungsinsitutionen darüber aufzuklären welche Vorteile aber auch Gefahren in einer programmierbaren und teilweise bereits programmierten Welt liegen. Wie weit erstrecken sich die Folgen der Programmierpraxis? Was ist Code, wo ist er und was heißt das für mich?

Ohne dieses Wissen gibt es keine Grundlage auf der basierend eine mündige Entscheidung für oder gegen das Programmierenlernen getroffen kann.

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 :)

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
Folgen

Erhalte jeden neuen Beitrag in deinen Posteingang.

Schließe dich 105 Followern an