// der php hacker

// archiv

Zwei Dinge, die mich immer schon an Webapplikationen genervt haben

Geschrieben am 16. Nov 2010 von Cem Derin

Es gab eine Zeit, da war eine Webapplikation nichts weiter als die etwas hübscher aufbereitete Darstellung von Daten die an gewissen wenigen Punkten sogar dynamisch war. Ich erinnere mich da an meine ersten Tage im Internet zurück. Damals war GMX so ein Dienst, wo man kostenlos eine Email-Adresse bekommen hat. Wow. Eine Email-Adresse. Sowas hatte nicht jeder – lag vielleicht auch daran, dass kaum einer (oder zumindest keiner den ich kannte) wusste, was das eigentlich ist. Über eine Weboberfläche konnte man Emails schreiben und lesen. Unglaublich unkomfortabel und hässlich – jedenfalls aus heutigen Gesichtspunkten.
// mehr lesen

Haben Design Pattern versagt?

Geschrieben am 10. Nov 2010 von Cem Derin

Beim morgentlichen stöbern durch die Entwickler-Blog-Welt bin ich auf einen Artikel aus Australien gestoßen, in dem die gewagte These aufgestellt wird: Design Patterns haben versagt. Es wird mit der Einleitung begonnen, dass man selbst so viele Design Pattern wie möglich benennen und erklären soll. Und zwar, bevor man weiterliest. Ein wenig Brimborium, Design Pattern sind ganz nett, aber schlussendlich gibt es ein Problem:

“Design patterns have flopped because most programmers don’t know design patterns well enough to recognise the recurring problems that they solve.”

zu Deutsch: Design Patterns haben versagt, weil die meisten Programmierer sie nicht gut genug kennen um zu verstehen, welche Probleme sie lösen.”

Vor allem in Verbindung mit dem ersten Absatz impliziert diese Aussage, dass man alle Design Pattern auswendig kennen muss, um sie richtig verwenden zu können. Das wird auch noch einmal damit unterstrichen, dass der Autor ganz offensichtlich aus dem Recruiting-Umfeld stammt, und Bewerber regelmäßig Pattern aufsagen oder erklären lässt. Zumindest ersteres wäre auch für mich ein Problem: Ich merke mir Sachen, die ich mir merken muss. Ich muss mir Sachen merken, wenn ich sie täglich Anwende. Ein Pattern wende ich aber nicht an, sondern ich setze das Resultat ein – es sei denn, ich entwickle etwas auf Grundlage von Pattern. Die allermeisten könnte ich aber aus dem Stehgreif erklären.

Ich sehe hier also keine Ambivalenz zwischen der mangelnden Fähigkeit rund 30 Pattern auswendig aufsagen zu können und der Tatsache, dass ich das Konzept dahinter nicht verstehe. Um zur Frage im Titel zurückzukommen: Nein! :)

Geschrieben in Entwicklung, Theorie 8 Kommentare

5 Motivationstipps (nicht nur) für Entwickler

Geschrieben am 09. Nov 2010 von Cem Derin

Wir alle lieben unseren Job. Wir machen ihn gerne, leidenschaftlich und können uns nicht vorstellen etwas anderes zu machen. Trotzdem: Manchmal hat man auch einfach keine Lust, ist frustriert von immer den gleichen Standardaufgaben oder es beschäftigen einen andere Dinge. Manchmal hat man dann die Möglichkeit sein Pensum herunterzuschrauben um sich nicht komplett zu frustrieren – aber oft verhindern Abgabetermine, Parallelprojekte und nicht zuletzt man selbst das. Da auch ich diese Probleme kenne möchte ich ein paar Tipps geben, wie man dem entgegenwirken kann – und vor allem dann, wenn das Kind schon in den Brunnen gefallen ist.
// mehr lesen

Liebe Webdesigner: Sein lassen!

Geschrieben am 05. Nov 2010 von Cem Derin

Wenn ihr Seiten für Leute baut, die Leute mit evtl. Sehproblemen auch lesen können sollen, dann lasst einfach so einen Scheiß wie Flash weg und baut nicht so doofe Knöpfe da rein. Sollte jemand eure Seite wirklich besuchen, dann weiß er schon, wie man mit einem Kommando die Schrift vergrößern kann … wenn das nicht ohnehin schon durch ein User-Stylesheet gelöst wurde! Mensch!

Geschrieben in Allgemein, Theorie 20 Kommentare

Über die Crux mit dem Kommentieren

Geschrieben am 04. Nov 2010 von Cem Derin

Ausnahmslos jeder Entwickler kennt das Problem: Schlecht kommentierter Code, der leider alles andere als selbstbeschreibend ist. Und Ausnahmslos jeder Entwickler hat selbst schon einmal solchen Code produziert. Sei es aus Faulheit oder aus vielleicht doch aus Unwissenheit – irgendwann mussten wir uns den Schuh mal anziehen. Ich möchte mal ein bisschen aus dem Nähkästchen plaudern, auch wenn ich mich damit heute mal nicht mit Ruhm bekleckere. Aber man muss ja auch mal in den sauren Apfel beissen können. Genug mit dem Phrasengedresche.

Früher, da war ja alles ganz anders, mein Kind!

Als ich meine ersten Zeilen Code geschrieben habe, da sah ja alles ganz anders aus. Kommentiert habe ich nur sehr wenig. Ich hab hier sogar noch ganz alten Code von mir gefunden, den ich euch nicht vorenthalten möchte!

	function user_overview($link) {
		include('../src/inc/config.php');
		if(!is_numeric($_GET['page'])) {
			$_GET['page'] = 1;
		}
		if($_GET['page'] <= 0) {
			$_GET['page'] = 1;
		}
		$curpage = $_GET['page'] - 1;
		$offset = $curpage * $G_MAX_USER_OVERVIEW;
		$query = "SELECT id, username FROM userdata_core LIMIT ". $offset.", ". $G_MAX_USER_OVERVIEW;
		$result = mysql_query($query, $link);
		while($data = mysql_fetch_array($result)) {
			$add = array_simple($add, "{USERNAME}", $data['username']);
			$add = array_simple($add, "{ID}", $data['id']);

			// In Loop-Array
			$user = array_loop($user, $add);
			unset($add);
		}

		// Navigation erstellen
		$query = "SELECT COUNT(id) FROM userdata_core";
		$result = mysql_query($query, $link);
		$data = mysql_fetch_array($result);
		$pages = ceil($data['COUNT(id)'] / $G_MAX_USER_OVERVIEW) - 1;
		$nav = create_navigation($curpage, $pages);

		// Template
		$source = file_get_contents('src/templates/user/overview.html');
		$source = parse_loop($source, $user, "{USER}");
		$source = parse_simple($source, $nav);
		return $source;
	}

Wir sehen: Kaum Kommentare, so wirklich versteht man nicht auf den ersten Blick, was ich da überhaupt mache. Zu meiner Verteidigung: Dieser Code stammt aus einem ziemlich  über das Knie gebrochene Projekt von vor über 6 Jahren. OOP war noch Neuland für mich, es musste schnell gehen, das Budget war klein.

In dem Projekt allerdings nutzte ich eine „Template-Engine“, die ich zuvor geschrieben habe. Komplett unkommentiert. Das habe ich dann im Anschluss nachgeholt, leider mit falsch Verstandenem Eifer. Jetzt war jede Zeile kommentiert, aber verstanden hat die Funktionen immer noch keiner (oder zumindest nicht, warum man nicht die nativen genommen hat). Veröffentlicht hab ich diese im Rahmen des „Developers Shame Day“. Deswegen nicht hier nochmal …

Jedenfalls: In den folgenden Jahren lebte ich also erst einmal nach der Devise: Um so mehr, desto besser. Ich habe alles mit Kommentaren zugepflastert. Dass das ungefähr genau so „nützlich“ ist wie überhaupt nicht zu kommentieren, merkt man erst, wenn jemand anders an den Code muss.

Wie also richtig kommentieren?

Gleichberechtigt mit guter Kommentier-Mentalität steht meiner Meinung nach die selbstbeschreibende Benamung von Klassen, Methoden, Variablen und Funktionen. Nichts ist Schlimmer als „getVarItmByFltr()“ oder „handleThis“ lesen und auseinanderklamüsern zu müssen. Eine gute Benamung kann einen Kommentar ersetzen – jedenfalls fast. Warum nur fast, dazu später mehr. In meiner Pipeline liegt noch ein Artikel, der einige Grundsätze und Faustregeln aufstellt, wie man Methoden, Klassen und Funktionen benennen sollte, damit klar ist, was passiert – und manchmal eben auch, was nicht.

Warum gute Benamung Kommentare (per Definition) nicht komplett unnötig macht, ist die gute alte DocSyntax. Diese sorgt daür, dass automatische Übersichten über eine Klassenstruktur erstellt werden können, und diese mit „menschenlesbarem“ Text versehen wird. Dort können auch Benutzungshinweise und „Zu Erledigen“ Markierungen angelegt werden. Zuguterletzt ist der große Vorteil für PHP auch noch, dass diverse Typ-Informationen von der IDE genutzt werden.

Trotzdem: Wer sich so eine generierte Dokumentation mal angesehen hat, der wird mir zustimmen, dass es nur unwesentlich besser ist, als sich den Code direkt selbst anzuschauen. Es ist halt nach wie vor automatisch generiert. Und eins darf man nicht vergessen: Diese Doc-Dinger werden aus dem Kommentarblock über der Signatur genommen. Was in der Methode (oder Klasse) passiert, bedarf ggf. auch noch einer Erklärung. Dabei sollte man beachten, dass man selbst vielleicht die abgefahrene Notation toll lesen kann, oder selbst die Haversine-Formel im Schlaf aufsagen kann … dass anderen aber evtl. nicht so geht. Deswegen, auch wenn man Methoden klein und kompakt hält: Erklörungsbedarf wird irgendwo immer sein. Erkennt ihn – und dafür gibt es leider keine Faustregel. Sicher ist nur: Wenn ihr es nicht in einem Satz und Allgemein-Verständlicher Sprache sagen könnt, dann muss ein Kommentar her ;)

For the LOLs!

Damit wir nun nicht nur Staubtrocken herumphilosophiert haben, hier noch eine recht lustige Seite mit den lustigsten Fundstücken in Code-Comments (war mir übrigens schon vor dem Developers Shame Day bekannt).

(Auf stackoverflow.com gibt es auch so einen „Thread“).

Geschrieben in Entwicklung 3 Kommentare

Meine erste „Template-Engine“

Geschrieben am 03. Nov 2010 von Cem Derin

Die Resonanz zum Developers Shame Day war überwältigend (Feedback auf Twitter, Facebook und im restlichen Netz). Ich habe ich mich sehr über das zahlreiche Feedback gefreut, und wenn ihr diesen Beitrag hier lest, werdet ihr wahrscheinlich auch in dem ein oder anderen Blog schon ein Stück Schamcode zu sehen bekommen.

Leider habe ich die Trackback-Funktion noch nicht in die Templates einbauen können, aber wenn ihr einen Kommentar mit einem Link hinterlasst, sollte das ja auch erst einmal reichen (zu mal häufig Trackbacks gar nicht bei mir ankommen).

Natürlich stelle ich mich auch den Geistern der Vergangenheit und hab das älteste Stück PHP aus meiner Feder herausgesucht, dass ich finden konnte. Zu dem Zeitpunkt habe ich schon mit PHP mein Geld verdient, habe angenommen, ich wäre ein „fortgeschrittener Programmierer“ und habe das Stück Code in unzähligen Projekten effektiv eingesetzt. Es handelt sich um eine Template-Engine. Früher war sowas beliebt. Früher wusste ich auch nicht, was eine Klasse ist und habe den Begriff inflationär – und falsch – verwendet!

Ich war früher unglaublich stolz, heute blicke ich selbst nicht mal mehr wirklich durch. Aber genug geredet. Ich verstecke mich und ihr dürft gucken!

<?php
     /*
       Template-Klasse v1.1
       von Cem Derin, 2002-2004
     */

       // Array Funktionen

       // Array für einfachen Parser
       function array_simple($srcarray, $name, $key) {
           // Indexzahl des übergebenen Arrays ermitteln
           $icount = count($srcarray);

           // Neues Item hinzufügen
           $srcarray[$icount]['name'] = $name;
           $srcarray[$icount]['key'] = stripslashes($key);

           // Array wieder ausgeben
           return($srcarray);
       }

       // Array für Schleifen-Parser
       function array_loop($srcarray, $addarray) {
           // Indexzahl des übergebenen Arrays ermitteln
           $icount = count($srcarray);

           //Neues Item hinzufügen
           $srcarray[$icount] = $addarray;

           //Array wieder ausgeben
           return($srcarray);
       }

       // Parser-Funktionen

       // Einfacher Parser
       function parse_simple($source, $replace) {
           // Indexzahl des übergebenen Arrays ermitteln
           $icount = count($replace);

           // Quelle ¸bergeben
           $quelle = $source;

           // Counter initialisieren
           $counter = 0;

           //Schleife starten
           while($counter < $icount) {
               // Variable in Quelle ersetzen
               $quelle = str_replace($replace[$counter]['name'], $replace[$counter]['key'], $quelle);

               // Counter erhöhen
               $counter = $counter + 1;
           }

           // Bearbeitete Quelle ausgeben
           return($quelle);
       }

       // Schleifen Parser
       function parse_loop($source, $replace, $loop) {
           // Die Quelle in Array schreiben
           $quelle = split($loop, $source);

           //Die Einträge zählen
           $q_count = count($quelle);

           // Den Quellen-Pointer initialisieren
           $q_counter = 0;

           // Die Routine für jeden Quelleneintrag wiederholen
           while($q_counter <= $q_count) {
	           // Prüfen, ob die Quellzeile eine Loop-Zeile ist
	           if(grade($q_counter) != 0) {
		           // Die Quellzeile ist eine Loopzeile
		           // Ermitteln, wieviele Datensätze der Loop-Array hat
		           $l_count = count($replace);

		           // Loop-Array-Counter initialisieren
		           $l_counter = 0;

		           // Die Routine für jeden Datensatz wiederholen
		           while($l_counter < $l_count) {
			           // Ermittlen, wieviele Items der Datensatz hat
			           $i_count = count($replace[$l_counter]);

			           // Itemcounter initialisieren
			           $i_counter = 0;

			           // Den Rohling erstellen
			           $rohling = $quelle[$q_counter];

			           // Die Routine für jedes Item wiederholen
			           while($i_counter < $i_count) {
				           // Rohling bearbeiten
				           $rohling = str_replace($replace[$l_counter][$i_counter]['name'], $replace[$l_counter][$i_counter]['key'], $rohling); 

				           // Counter erhoehen
				           $i_counter = $i_counter + 1;
			           }

			           // Den Rohling mit den Vorgängern verbinden
			           $output = $output. $rohling; 

			           // Loop-Array Counter erhöhen
			           $l_counter = $l_counter + 1;
		           }

		           // Die neue Zeile eintragen
		           //$quelle[$q_counter] = $output;
		           $return = $return. $output;
		           $output = $NULL;

	           } else {
		           // Eine Grade Zahl, kein Loop
		           $output = $output. $quelle[$q_counter];
	           }

	           // Quellen-Pointer erhöhen
	           $q_counter = $q_counter + 1;
           }

           // Ausgabe
           return($return);

       }

       // Ist eine Zahl grade
       function grade($zahl) {
	       return($zahl % 2);
       }
?>

Und frei zur Verfügung gestellt hab ich das damals auch schon hier! Da gibts sogar noch ne Anleitung!

theme von mir, software von wordpress, grid von 960 grid system. funktioniert in allen browsern, aber der safari bekommt das mit der schrift am schönsten hin.