ilimitado Web Entwickler Blog

… oder die Geschichte vom Programmieren lernen.

Wie wird man eigentlich professioneller Programmierer, ab wann darf man sich einen Hacker nennen und was ist auf diesem Weg alles zu beachten?

In den letzten Wochen musste ich feststellen, dass programmieren nicht gleich programmieren ist. Meine Anschauung hat sich da etwas geändert. Ich möchte zunächst meinen Weg beschreiben, wie ich Programmierer wurde.

Angefangen hat es zu Schulzeiten. Im Informatik Unterricht habe ich das erste Mal vom Programmieren gehört. Mehr als das Ausgeben von Strings, das Addieren und Subtrahieren stand aber nicht auf dem Programm. Das Programmieren war zunächst eine Art Spiel. Ohne ein echtes Ziel zu verfolgen konnte ich etwas zusammen tippen, das Programm starten und mich freuen das etwas auf dem Bildschirm passierte.

Das sah dann vom Prinzip her so aus:

  echo "Hello 1. World";
  echo "Hello 2. World";
  echo "Hello 3. World";
  #und so weiter... bis 10...

Irgendwann habe ich dann angefangen auch nützliche Dinge zu programmieren wie zum Beispiel Mathematische Rechenaufgaben. Ich konnte mir den Taschenrechner ersparen und vor allem sich wiederholende Berechnungen nicht immer wieder eingeben, ich lernte also Variablen und Schleifen zu nutzen.

  for($x=0; $x<=10; $x++)
  {
    echo "Hello $x. World";
  }

Weil das alles irgendwie Spaß gemacht hat, beschloss ich dann irgendwann Informatik zu studieren und so saß ich dann recht bald in meine ersten Informatik Vorlesung an der Eberhard Karls Universität in Tübingen. Soweit so gut, als normaler, durchschnittlicher, typisch deutscher Student habe ich von all den guten Dingen die dort erzählt wurden wenig mitgenommen und gedacht programmieren kann ich ja schon das bisschen Theorie hier braucht später eh kein Mensch.
Begriffe wie UML, Objektorientierte Programmierung gingen zum einen Ohr rein zum anderen wieder raus. Die mehr als lächerlichen Übungsaufgaben konnten durch zusammentippen einiger Befehle programmiert werden. Dabei entstanden äußerst komplexe Quellcodes, dank meines neuen Wissens über Arrays und Stringoperationen, die trotz guter Dokumentation (denn Dokumentation ist unglaublich wichtig) niemand verstand und die mit Sicherheit alles andere als gut waren, ob sie wirklich funktioniert haben weis ich auch nicht, für den einen Fall den ich getestet habe wohl schon…

Ab hier gehts gemeinsam weiter, ich lernte den späteren Mitbegründer der ilimitado OHG, Stephan kennen.
Jetzt konnten wir also programmieren und hatten zusätzlich noch gelernt den Quellcode gut zu dokumentieren, waren also fast schon ernst zunehmende Programmierer. Schaut selbst:

 
  //aa steht für AlphabetArray, es enthält die Buchstaben a bis z
  $aa[1] = "a";
  $aa[2] = "b";
  $aa[3] = "c";
  $aa[4] = "d";
  $aa[5] = "e";
 
  # Den Rest erspar ich dem Leser an der Stelle mal es ist klar wie es weiter geht...
  
  //Das ist eine for-Schleife, sie wiederholt 10 mal die Ausgabe
  for($x=0; $x<=10; $x++)
  {
    //hw steht für Hello World
    $hw="";
    //Hier wird auf das Alphabet Array an der Stelle 8 zugegriffen, also auf das h
    $hw.=$aa[8];
    //Als nächstes wird das e ausgelesen:
    $hw.=$aa[5];
 
    # Auch hier will ich mal den Rest ersparen....
    
    //Zum Schluß muss noch zwischen Hello und World das derzeitige X eingefügt werden:
    //Hier wird erstmal ein String zum ersetzen gebaut es steht für Ersetzungsstring:
    $es = "$x. W";
    //Der Befehl str_replace sucht nach einem vorkommenden String in $hw und ersetzt ihn durch $es.
    $hw=str_replace(" W", $es, $hw);
    echo $hw;
  }

Der nächste Schritt war den Begriff Algorithmus kennen und fürchten zu lernen. War das Programmieren bisher mehr oder weniger ein „der Maschine irgendwie beibringen etwas zu tun“ wurde es auf einmal zu einem „der Maschine beibringen etwas so zu tun wie wir das wollen“.
Außer if-Schleifen und Variablen kamen von da an Listen, Arrays und manchmal sogar Bäume zum Einsatz. Schnell war klar, dass was bisher so programmiert wurde war eigentlich alles wertlos und peinlich noch dazu.
Begriffe wie Hashtabelle, Sortieralgorithmen, Stringoperationen begeisterten zu abenteuerlichen Programmen, welche wie im ersten Semester gelernt bestens dokumentiert wurden… dass wir Nachts ja schon von großen Programmierleistungen zu träumen gewagt haben und arrogante Gedanken hatten, wie man nur, wo doch alles so einfach ist, so viele Bugs in Software findet. Schließlich bieten Programmiersprache so tolle Funktionen, man kann mit Strings verdammt viel manipulieren, ob Java oder PHP egal,… programmieren heißt möglichst viele Funktionen der Programmiersprache zu benutzen!
Endlich machten wir auch Gebrauch von sogenannten Funktionen, da wir gelernt hatten so Spaghetti Code zu vermeiden…
Wir waren uns sicher, jetzt sind wir bald professioneller Programmierer, hatten schließlich schon 4 Semester Informatik studiert:

  class verkettete Liste()
  {
    # auch das erspare ich dem Leser, hier steht also alles 
    # fein säuberlich dokumentiert, was man für eine Listenimplementierung 
    # so braucht, programmiert nach Lehrbuch...
  }
 
  function hello_world()
  {
    $aa = alphabetarray();
 
 
    //Das ist eine for-Schleife, sie wiederholt 10 mal die Ausgabe
    for($x=0; $x<=10; $x++)
    {
      //hw steht für Hello World, und ist vom Datentyp Liste
      $hw= new verketteteListe();
      //Hier wird auf das Alphabet Array an der Stelle 8 zugegriffen, also auf das h
      $hw->add($aa[8]);
      //Als nächstes wird das e ausgelesen:
      $hw->add($aa[5]);
 
      # Auch hier will ich mal den Rest wieder ersparen....
      
      //hwa steht für hello world Ausgabe, die liste wird in einen string gepackt. 
      //y ist hier nur so eine temporäre Variable und $x war ja schon für die Schleife vergeben
      foreach ($hw as $y)
      {
        $hwa .= $y; 
      }
 
      //Zum Schluss muss noch zwischen Hello und World das derzeitige X eingefügt werden:
      //Hier wird erst mal ein String zum ersetzen gebaut es steht für Ersetzungsstring:
      $es = "$x. W";
      //Der Befehl str_replace sucht nach einem vorkommenden String in $hwa und ersetzt ihn durch $es.
      $hw=str_replace(" W", $es, $hwa);
      echo $hwa;
  } 
 
 
  }
  /* Diese Funktion ist eine Hilfsfunktion für hello world
   * Sie befüllt das Array aa mit den Buchstaben a bis z.
   */
  function alphabetarray()
  {
    //aa steht für AlphabetArray, es enthält die Buchstaben a bis z
    $aa[1] = "a";
    $aa[2] = "b";
    $aa[3] = "c";
    $aa[4] = "d";
    $aa[5] = "e";
    # Den Rest erspar ich dem Leser an der Stelle wieder...
    return $aa;
  }
 
  //führt hello world aus
  hello_world()

Es folgten Semester 5 und 6 und wir hatten mit ganz neuen Schwierigkeiten zu kämpfen. Ein Webserver sollt eingerichtet werden, wir lernten, dass eine Linux Kommando Konsole (Shell) anscheinend ohne Maus funktioniert und dass man ständig die gleichen Befehle eintippen muss.
Endlich war es soweit, wir konnten unsere Kenntnisse über das Programmieren einsetzen, und schrieben kleine Bash Scripte, um oft benötigte Befehle abzukürzen. Dabei lernten wir dann auch der Funktion Parameter zu übergeben um unsere gespeicherten Befehle, also Programme noch etwas beeinflussen zu können, damit wir nicht für jedes kleine bisschen gleich ein neues Programm schreiben mussten:

 
  function hello_world($i)
  {       
    //Das ist eine for-Schleife, sie wiederholt $i mal die Ausgabe
    for($x=0; $x<=$i; $x++)
    {
      echo "Hello $x. World";
    } 
  }
 
  //Führt 10 mal das Hello World aus...
  hello_world(10)

Programmieren war also nun lang kein Spiel mehr, oder das Umsetzen von Gerüsten wie Hashtabellen, verkette Listen, nein Programmieren erleichterte nun die Arbeit, unsere Programme waren Shortcuts, sie kürzten die Befehle ab, zählte uns insgeheim schon zu den Linuxprogrammieren und träumte vom eigenen Betriebsystem, basierend auf Linux, selbst konfiguriert, mit eigenen Scripten, Tools, Anwendungen etc.

Als nächstes auf dem Weg stand es an Homepages zu programmieren. Natürlich verstanden wir erst mal nicht warum 1. an der Uni jeder behauptet HTML sei keine Programmiersprache und 2. PHP genauso wenig. Doch dann verstand ich es recht bald, HTML ist nämlich eine Markup Sprache, welche einen Text nur auszeichnet und einem Browser sagt wie was interpretiert werden soll (Link, Bild, Tabelle etc.) eine Scriptsprache wird interpretiert arbeitet und berechnet etwas und eine Programmiersprache arbeitet viel Systemnaher und bietet schier unendliche Möglichkeiten.

Mit den guten Erfahrungen in Linux und mit den Bashscripten begannen wir in PHP ähnlich vorzugehen, wir schrieben Funktionen und Programmfragmente für unsere Homepages um nicht ständig im Code alles neu zu programmieren. Wir verstanden, was eine Funktionsbibliothek ist, nannten unsere PHP Dateien stolz eine Library.
Ab jetzt wurde der Ansatz verfolgt Code immer wieder verwenden zu können und sich so in Zukunft Arbeit zu ersparen.
Wir konnten nun also programmieren, konnten der Maschine sagen was sie wie tun soll, hatten gelernt alles was wir programmieren zu dokumentieren und waren uns sicher bald alles nur erdenkliche programmieren zu können.

Da war der nächste Schritt einfach total logisch eine Firma zu gründen und das Wissen zu Geld zu machen ilimitado GbR war geboren.

Irgendwie hat das aber nicht funktioniert, wir konnten wenig vom Code in anderen Projekten verwenden mussten immer alles neu anpassen, wen man überhaupt noch verstand, was da hingetippt worden war.

Irgendwie sind wir dann wieder auf Objektorientierte Programmierung gestoßen, angefangen Klassen zu schreiben, und Objekte zu erzeugen und Funktionen auf Objekten aufzurufen, ein großer Unterscheid zu den bisherigen Programmen gab es aber dann doch nicht.

 
  /* Das ist eine Klasse, sie stellt Funktionen bereit, welche ständig gebraucht werden.
   */
  class homepage
  {
    /* diese Function zeigt Hello World an:
     */
    public function hello_world($i)
    {       
      //Das ist eine for-Schleife, sie wiederholt $i mal die Ausgabe
      for($x=0; $x<=$i; $x++)
      {
        echo "Hello $x. World";
      } 
    }
  }
 
  //erzeugt ein Objekt vom Typ Homepage
  $hp = new homepage();
  //Führt 10 mal das Hello World aus...
  $hp->hello_world(10);

Endlich fingen wir auch an im Team zu arbeiten. Unser Quellcode war nicht mehr eine private Spielweise, sondern musste gepflegt und von anderen betrachtet werden. Erinnerungen ans erste Semester wurden wach, ein Codingstyle musste her. Variablen wurden nun konsequent benannt, Einrückungen etc. werden eingehalten, kommentiert wurde zwar noch, aber nicht mehr was man hier wie programmiert hat und was die Befehle alle bedeuten, sondern lediglich was hier umgesetzt wurde, da man ja davon ausgehen sollte, dass der Leser des Codes die Programmiersprache kennt.
Wir waren durchaus zufrieden, der Code war nun nicht nur vom Programmierer lesbar, sondern auch vom Team und es funktioniert alles so schön, so schlecht konnten doe Programmier Kenntnisse also nicht sein:
Die ersten beiden Kundenprojekte sind auch heute noch Online, funktionieren perfekt und es gab seitens der Kunden auch nie beschwerden.

 
  /* Funktionsbibliothek für Webdesigner
   */
  class homepage
  {
    /* diese Function zeigt Hello World an:
     */
    public function hello_world($anzahl)
    {       
      for($x=0; $x<=$anzahl; $x++)
      {
        echo "Hello $x. World";
      } 
    }
  }
 
  $homepage = new homepage();
  $homepage->hello_world(10);

Es folgt Semester 7 und wir wagten ein größeres Programmier Projekt. Mit dem Wissen über Funktionsbibliotheken und objektorientiertem Programmieren sollte für die vielen Homepages die wir mal (irgendwann) für unsere Kunden erstellen werden, ein eigenen CMS her. Selbst programmiert und mit Möglichkeiten ganz auf unsere Bedürfnisse zugeschnitten. Wir lernten DOM kennen und hatten endlich konkrete Vorstellung was Objekte sind. Jetzt war es soweit, wir fingen an das CMS zu planen, schrieben auf was es können soll, und tippten drauf los. Irgendwie war das aber alles auf einmal nicht so leicht. Es traten urplötzlich Probleme auf. Die Vorstellungskraft, wie alles mal funktionieren soll, reichte einfach nicht aus.
Ein paar Bücher später, mittlerweile war ilimitado eine OHG uns das CMS konnte schon Sessions verwalten und hatte ein eigenes kompliziertes Loggsystem, gingen wir dann in die nächste Ära der Programmierung.
Design Patterns, auf deutsch Entwurfsmuster, waren nun das magische Wort. Unglaublich aber wahr, Objekte können miteinander reden. Klassen können andere Klassen instanzieren, Dinge laufen automatisch ab, objektorientierte Programmierung war neu entdeckt.

Seither wird endlich wirklich in Objekten gedacht, schnell war klar UML muss her, es muss geplant werden. Verfahren und Vorgänge müssen in UML Diagramme gepackt werden, alles muss anders und neu organisiert werden. Alle Klassen und Objekte müssen sich gegenseitig informieren und austauschen. Objekte schwirren erst mal nur umher und bekommen erst zur Laufzeit als Gesamtheit eine Funktion, alles wird dynamisch, nichts ist mehr so statisch wie früher.
Endlich entwerfe ich Klassen, die völlig unverändert in vielen Projekten wieder verwendet werden können.
Eine API wird designed und Interfaces eingesetzt, abstrakte Klassen definiert, Fabriken und Adapter entworfen, Muster angewendet…. Objekte registriert und mit einander verknüpft.
Stichpunkte wie Iteratorschnittstelle, Reflection API, Entwurfsmuster, serialisieren von Objekten sind nun ganz vorne mit dabei.

Schockiert schauen wir auf unsere Codes, auf den Kinderkram den wir vor ein paar Wochen noch für das Maß aller Dinge gehalten haben. Es steht schon mal fest, wir sind ganz gut im Skripten und im Computer bedienen und der Linuxshell mal kurz ein paart Shortcuts beizubringen aber vom Programmieren haben wir bisher mal so was von keine Ahnung gehabt.

Was ist also eine Programmiersprache, was ist programmieren? Nun, eine Programmiersprache ist auch nicht viel mehr als eine API, es ist eine Möglichkeit und Hilfe den Computer zu instruieren, PHP bietet eben von Haus aus viele schöne Funktionen, welche man im Internet und für Homepages braucht, Java und C++ bietet eben gute Anbindung ans Betriebsystem z.B. für eine GUI…

Wie heute unser Hello World Programm aussieht? Nun Hello World ist und bleibt Hello World, da braucht’s einfach nichts weiter als:

  for($x=0; $x<=10; $x++)
  {
    echo "Hello $x. World";
  }

Was wir nun noch lernen müssen, und wo wir nun noch Erfahrung brauchen ist, wann wende ich welche bekannten Muster an, wie organisiere und plane ich meine Objekte, was sind gute Interfaces…
Wann ist die Abstraktion in Objekte einfach zu krass, wo muss man aufhören zu kapseln?
Dann kann man sich langsam mal überlegen wie man seinen Code durch geeignetes Refactoring verbessert und vielleicht effizienter macht.
Und wenn wir dann mal eines Tages, nach jahrelangem programmieren und schier unendlichen Erfahrungen, einen 6 Wochen alten Code von uns anschauen und wir immer noch mit ihm zufrieden sind, und wir unsere Programme einfach nur noch so runtertippen können, ja dann, dann dürft ihr uns von mir aus endlich Hacker nennen

Kurzfassung, in 12 Schritten zum Hacker:

Lerne, was programmieren ist, schreibe ein paar echos und freu dich
Lern Variablen kennen, spar dir Arbeiten durch Schleifen und Berechnungen
Lern Elemente einer Programmiersprache kennen, was bietet die Sprache an Funktionen?
Lern deinen Code in Funktionen auszulagern, mach dir klar was eine Funktionsbibliothek ist.
Such dir ein Team, kontrolliert gegenseitig euren Code
Einigt euch auf einen Codingstyle
Mach dich an ein großes Projekt, kapiere, dass du um das alles zu strukturieren Objektorientierte Programmierung brauchst
Lerne planen, analysieren und in UML zu notieren
Lerne was Entwurfsmuster sind, lerne sie anzuwenden, kapiere, dass man es damit nicht übertreibt.
Lerne Code Wegzuwerfen und zu refaktorn
Programmiere so, dass egal welche Programmiersprache, egal welches Problem deine Konstrukte stets wieder verwendet werden können
und löse die komplexesten Dinge einfach so im Schlaf

Ungefährer Zeitaufwand, je nach dem 10 bis 20 Jahre

So, jetzt wisst ihr wie es geht und braucht nur noch die paar Bücher