Stas Malyshev (Zend Angestellter und PHP Core Entwickler) hat in seinem php100 Blog 2 Artikel in dem einen wird der Google Artikel unter die Lupe genommen. Im anderen werden echte Tipps gegeben. Die meisten davon sollte jeder PHP Programmierer schon gehört haben. Ein drüber lesen schadet auf keinen Fall.

• PHP performance tips from google by Stas Malyshev
• More on PHP performance by Stas Malyshev

Eher zufällig stolperte ich heute über debug_backtrace und debug_print_backtrace. (Gruß an Matthias)

Wenn man in PHP5 Coded und eifrig Exceptions verwendet kennt man sicher Exception::getTrace() bzw Exception::getTraceAsString() debug_[print_]backtrace macht im prinzip das selbe, es liefert ein Array bzw String mit dem Backtrace der aktuellen Funktion.

Und warum hab ich das bislang nicht gebraucht, keine Ahnung.

Vorschläge für weitere Perlen gerne in den Kommentaren.

Mein persönliches Highlight: Zend_Db_Table und Joins arbeiten endlich wie sie sollen.

Problemstellung:

Ich bin gerade dabei eine ziemlich große mehrteilige API zu schreiben. Diese API wird von anderen Programmieren verwendet. Mein Problem ist nun, wie handle ich das ErrorReporting.

Klar, ich kann für jede meiner Hauptklassen eigene Exception Klassen schreiben, die müssten aber wiederum eigene Exception Codes ausgeben damit die Programmierer welche die API verwenden wissen wie sie darauf reagieren sollen. Eigentlich wollte ich es vermeiden eine Liste mit Fehlercodes zu erstellen. (ob nun mit oder ohne Exceptions)

Ich wollte Exceptions eigentlich nur verwenden wenn “Unerwartetes” passiert. ZB. keine Datenbankconnection, File konnte nicht ins Filesystem geschrieben werden… solche Dinge. Darüber hat auch Nils Langner in seinem Blog schon geschrieben.

Also liebe PHP-Bloggemeinde. Was ist die best Practice in so einem Fall ?

Bis vor nicht allzu langer Zeit “malte” ich die Mockups per Hand oder in DIA, aber diese Zeiten sind vorbei. Habe endlich ein Mockup Tool gefunden mit dem ich schnell und ohne große Probleme die Sketches erstellen kann. (OK, das hört sich stark nach Werbung an, soll es aber gar nicht sein. Um ehrlich zu sein, noch nie habe ich so schnell UI’s entworfen wie mit diesem Tool).

Probiert es mal selber aus, auf der Website von Balsamiq gibts eine Web Version zum herumspielen.

(Bilder Copyright by www.balsamiq.com)

Es gibt natürlich immer jemanden dem es nicht gefällt. Warum auch nicht, wir haben ja immer noch den “Freedom of Choice”. Einer der einen netten Artikel darüber geschrieben hat ist Andy Budd (auch die Kommentare lesen ! . Man sollte dazusagen dass Andy in erster Linie Grafiker bzw. Designer ist, da ist der Zugang ein anderer. (zb. verwendet Balsamiq Comic Sans als default Font) Zurück zum Freedom of Choice, Garry Barber hat auf Sitepoint eine kleine Zusammenstellung von Mockup Applikationen.

Have you ever felt the need to cache Databaseresults ? Of course you have. Do you also use Zend_Db_Table for the less complex queries ? Then this may be interesting for you.

Of course, these simple queries would easily fit in MySQL (or any other DB) query cache. But maybe you want to save this for your complex queries building Tmp-Tables in MEMORY. Or for whatever reason, here is a solution.

You find the full classes on my svn.

The basic idea is from Pascal Opitz with contributions from Robert Kummer and Sascha-Oliver Prolic. Their version is great but does not work with Zend_Db_Table.

Let’s start with extending Zend_Db_Table_Abstract:

abstract class Cwd_Db_Table extends Zend_Db_Table_Abstract {
	/**
	 * @var Cwd_Db_Cache
	 */
	public $cache;

	protected $_rowClass ='Cwd_Db_Table_Row';

	public function __construct($config=array()) {
		parent::__construct($config);
		/**
		 * @var Cwd_Db_Cache
		 */
		$this->cache = new Cwd_Db_Cache($this);
	}
}

We just add the cache to it and set the protected var $_rowClass, this is needed because we want the results to be of our own implementation of Zend_Db_Table_Row_Abstract.

Our implementation looks like this:

class Cwd_Db_Table_Row extends Zend_Db_Table_Row_Abstract {
	/**
	 * @var Cwd_Db_Cache
	 */
	public $cache;

	public function __construct($config=array()) {
		parent::__construct($config);

		$this->cache = new Cwd_Db_Cache($this);
	}

	public function setTable(Zend_Db_Table_Abstract $table = null)
    {
        if ($table == null) {
            $this->_table = null;
            $this->_connected = false;
            return false;
        }

        $tableClass = get_class($table);

        /**
        // we lost $this->_tableClass, so this would throw always an exception
		// we have to ignore this for now.

        if (! $table instanceof $this->_tableClass) {
            require_once 'Zend/Db/Table/Row/Exception.php';
            throw new Zend_Db_Table_Row_Exception("The specified Table is of class $tableClass, expecting class to be instance of $this->_tableClass");
        }
		*/

        $this->_table = $table;
        $this->_tableClass = $tableClass;

        $info = $this->_table->info();

        if ($info['cols'] != array_keys($this->_data)) {
            require_once 'Zend/Db/Table/Row/Exception.php';
            throw new Zend_Db_Table_Row_Exception('The specified Table does not have the same columns as the Row');
        }

        if (! array_intersect((array) $this->_primary, $info['primary']) == (array) $this->_primary) {

            require_once 'Zend/Db/Table/Row/Exception.php';
            throw new Zend_Db_Table_Row_Exception("The specified Table '$tableClass' does not have the same primary key as the Row");
        }

        return true;
    }	

    /**
     * Set the table
     * this is necessary if the row lies in cache
     *
     * also we aresetting automatically a cache suffix
     *
     * @param $table Zend_Db_Table_Abstract A instance of a model.
     */
    public function prep($table){
    	$this->setTable($table);
        $table=$this->getTable()->info();
        $tablename=$table['name'];
        $primary=$table['primary'][1];

        $this->cache->setCacheSuffix($tablename.'__'.$this->$primary.'__');
    }
}

Ok, what did we do. We have our cache in it, and are overwriting the setTable method.  If the row is stored in the cache, we lose _tableClass, and the only way to set it right again is to use the setTable method, but unfortunatly this method is checking if the table object we give to it is the same as the object in _tableClass … you see the problem. So we have to overwrite this only to comment this part out.

At the bottom you see a new prep method. This method calls the setTable method and also sets a cache suffix. This is needed becouse the Zend_Cache_Frontend_Class generates the id only by method name and parameters, but not on contents of the object. So if you have a loop and for example use findParentRow() in it, you would get the same row for every  Query from the cache. This is not what we want. So we autoextend the cache suffix by the primary key column with the value of the primary key. (in the current version, there is no check if the primary key has more than one field. If you need this feel free to overwrite/extend my class)

To make use of these classes you just have to build your models by extending Cwd_Db_Table instead of Zend_Db_Table_Abstract.

If you have done so, you can use it like in the following example:

    	$m_event = new EventModel();
    	$m_act = new ActModel();
    	$events = $m_event->cache->fetchAll(array("status='1'","deleted='0'"),'createdate desc',10,0);
    	echo "<ul>";
    	foreach($events as $event){
    		echo "<li>".$event->event_id."</li>";
			$event->prep($m_event);

    		$acts = $event->cache->findDependentRowset('ActModel');
    		echo "<ul>";
    		foreach($acts as $act){
    			$act->prep($m_act);
    			$foo = $act->cache->findParentRow('EventModel');
    			echo "<li>".$act->act_id." (".$foo->event_id.")</li>";
    		}
    		echo "</ul>";
    	}
    	echo "</ul>";

Easy, isn’t it ? The caching is flexible, so it doesn’t matter if all rows are in the cache. All combinations are working. To bypass the cache you can use the model directly without the ->cache->.

The cache class is using Zend_Config for some parameters, for reference here are the values:

caching.cache_by_default	= true
caching.default_cache_id_prefix	= default_
caching.lifetime			= 300
caching.backendName			= Memcached

Rauf, Rauf, Runter, Runter, Links, Rechts, Links, Rechts, B, A

Dieser “Cheat” führte je nach Spiel Unterschiedliches aus, mal nur ein EasterEgg, mal ein Cheat (extra Leben, PowerUps… das übliche halt). Die Code Sequenz wurde so berühmt dass sie (teilweise in leichter Abwandlung) auch von anderen Herstellern verwendet wurde. Eine Liste findet sich zB. auf Wikipedia.

Das alles wäre natürlich keinen Blogeintrag wert wenn es da nicht eine doch interessante Entwiklung gäbe. Immer mehr Websites verstecken EasterEggs hinter einem Konami Code. Beispiel gefällig ? Geht einfach mal auf http://jquery.com und gebt den Code ein.

JQuery ist aber nicht die einzige Seite die das macht. Es gibt mittlerweile viele Seiten die den Code verwenden. Eine Liste von Seiten ist zu finden auf Konami Code Sites, um Zugang zur Seite zu erhalten ist die Eingabe des Codes erforderlich.

Probiert es aus, ich habe es mir schon fast angewöhnt bei größeren Seiten auch den Code einzugeben.

Um einen Konami Code in die eigene Seite einzubinden kann zB. Jquery verwendet werden. Joe Mastey hat dazu eine kleines JQuery Plugin geschrieben.

Only wimps use tape backup: _real_ men just upload their important stuff on ftp, and let the rest of the world mirror it. ”
— Linus Torvalds

Aber zu Deiner Idee, ich halte das für eine nette Gedankenspielerei, aber ich finde der Sinn eines Backups ist es auch in der schnellstmöglichen Zeit wieder online zu sein. Wenn der Hoster keine Cronjobs bietet (… schlechter Hoster btw.) wäre es wohl einfacher ein paar Zeilen Code zu schreiben welche in die Seite eingebunden werden, und periodisch (zB. jeden Tag oder alle paar Stunden, je nach Änderungshäufigkeit) die Datenbanken und wichtigen Files in ein Archiv zu packen und zu archivieren.

Dabei gibt es wieder zwei Varianten, entweder von einem Server der Cronjobs bietet eine bestimmte URL aufrufen, welche den Backup Prozess anstößt, oder wenn auch das nicht möglich ist, über Triggers die bei jedem Seitenaufruf ausgeführt werden.

Für letzteres eignet sich “selbst modifizierender Code” ganz gut. Bei jedem Seitenaufruf wird eine PHP Datei inkludiert die zB. nur folgendes enthält:

<?php $lastrun = 123456789; # Timestamp of last run ?>

Dann wird einfach überprüft ob $lastrun länger als zB. 24h zurückliegt,  wenn ja wird das Backup angestossen. Jetzt muss nur noch die Datei aktualisiert werden, indem der aktuelle Timestamp in die Datei geschrieben wird.

1967 startete der Psychologe/Soziologe Stanley Milgram (übrigends der selbe welcher das “Milgram Experiment” durchführte) das “Small World” Experiment. Milgram erstellte eine Art Informationspaket, das 60 zufällig ausgewählte Teilnehmer an jeweils eine vorher festgelegte Person in Boston zu senden hatten. Als Startpunkte wählte er Personen aus den sozial und geografisch weit von der Zielstadt entfernten Städten Omaha und Wichita. Die Aufgabe der Teilnehmer bestand darin, das Paket nicht direkt an die Zielperson zu senden, sofern sie diese nicht persönlich kannten (bei ihrem Vornamen ansprachen), sondern an eine Person, die sie persönlich kannten und bei der die Wahrscheinlichkeit höher war, dass sie die Zielperson kannte. Gleichzeitig waren die Teilnehmer angehalten, grundlegende Daten über sich selbst in einer Tabelle zu vermerken und eine Postkarte an die Wissenschaftler zu senden, um die Kette nachvollziehbar zu machen. Insgesamt erreichten drei Pakete die Zielpersonen mit einer durchschnittlichen Pfadlänge von 5,5 oder aufgerundet sechs. Die Wissenschaftler schlossen daraus, dass jede Person der US-amerikanischen Bevölkerung von jeder anderen Person der USA durchschnittlich durch sechs Personen getrennt ist oder, andersherum formuliert, durch durchschnittlich sechs Personen erreicht werden kann. In einem zwei Jahre später durchgeführten Experiment mit 296 möglichen Ketten wurden 217 Pakete gestartet und 64 erreichten ihr Ziel.^[1] Im Jahre 1970 folgte ein weiterer Versuch, der, neben der Entfernung der Menschen untereinander, auch mögliche Grenzen zwischen ethnisch unterschiedlichen Gruppen untersuchen sollte. Von 270 mit afroamerikanischen Personen als Ziel gestarteten Paketen erreichten 13 % diese Person, während 33 % von wiederum 270 an „weiße“ Personen adressierte Pakete ihr Ziel erreichten.

Möchte man jetzt die Verbindung von Person A zu Person B darstellen, läuft man schnell in das “shortest path problem“. Um dies zu lösen eignet sich der sogenannte “Dijkstra-Algorithmus“. Wie sieht jetzt die Implementierung in PHP aus ? Wir nehmen an wir haben eine Tabelle mit unseren Usern, und eine zweite welche die Verbindungen der User untereinander darstellt (fromid => toid).

CREATE TABLE IF NOT EXISTS `users` (
`id` int(11) NOT NULL auto_increment,
`firstnames` varchar(200) NOT NULL,
`lastname` varchar(200) NOT NULL,
PRIMARY KEY  (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=22 ;

CREATE TABLE IF NOT EXISTS `links` (
`link_id` int(11) NOT NULL auto_increment,
`fromid` int(11) NOT NULL,
`toid` int(11) NOT NULL,
PRIMARY KEY  (`link_id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=11 ;

Als erstes brauchen wir den theoretisch längsten Pfad: Dies wäre die Anzahl der User +1. Nächster Schritt - das Basis array, welches die Schritte von Person x zu Person y festlegt, da wir dies aber noch nicht wissen inintialisieren wir das array mit -1 (unbekannter Pfad). Einen Pfad kennen wir jedoch, nämlich den Pfad von $fromid zu $fromid. Dieser hat die Distanz 0.

	private function _fetchUser(){
		$m_user = new UserModel();
		$this->_users = $m_user->fetchAll();
		$this->_longestPath = $this->_users->count()+1;
	}

	private function _buildSkel($fromid){
		if(!$this->_users){
			$this->_fetchUser();
		}

		foreach($this->_users as $user){
			$this->_nodes[]=$user->id;
			$this->_dist[$user->id]=$this->_longestPath;
			$this->_previous[$user->id]=-1;
		}

		if($fromid>0)
			$this->_dist[$fromid]=0;
	}

Jetzt beginnt der Spass, das Suchen des kürzesten Pfades von User A zu User B:

	private function _findPath($toid){
		$Q = $this->_nodes;
		while(count($Q)>0){
			$qsize=count($Q);
			$unode = $this->_findMin($Q);

			if($unode == $toid){
				break; // We have found ToId
			}

			$u = array_search($unode, $Q);
			$Q[$u]=false;

			$Q = array_filter($Q);

			if($qsize == count($Q)){
				throw new Exception("Qsize doesnt shrink!");
			}

			$m_link = new LinksModel();

			$invitees = $m_link->fetchAll("fromid='$unode'");
			$inviters = $m_link->fetchAll("toid='$unode'");

			if($invitees->count()>0)
				$this->_relaxNeighbors($unode,$invitees,'toid');

			if($inviters->count()>0)
				$this->_relaxNeighbors($unode,$inviters,'fromid');

		}
	}

	private function _relaxNeighbors($unode,$neighbors,$col){
		foreach($neighbors as $neighbor){
			$this->_relax($unode,$neighbor->$col);
		}
	}

	private function _relax($u,$v){
		if($this->_dist[$v] > $this->_dist[$u]+1){
			$this->_dist[$v]=$this->_dist[$u]+1;
			$this->_previous[$v] = $u;
		}
	}

	private function _findMin($nodes){
		$keys = array_keys($nodes);
		$minid = $nodes[$keys[0]];
		$mindist = $this->_dist[$minid];

		foreach ($keys as $key){
			$tnode = $nodes[$key];
			if($this->_dist[$tnode] < $mindist){
				$mindist = $this->_dist[$tnode];
				$minid=$tnode;
			}
		}

		return $minid;

	}

Wir laufen also unsere Knoten durch und berechnen die Kantenlängen für jeden Knoten. Dabei wird ein bereits bekannter kürzester Weg benutzt und um eine Kante (zu dem jeweils nächsten) Nachfolgeknoten ergänzt. Dadurch entsteht letztendlich eine Baumstruktur, welche die kürzesten Wege von einem Startknoten repräsentiert. Die gesamte Klasse findet sich auf http://www.cwd.at/shortestpath.phps Raum für Optimierung gibt es genug. ZB. das Errechnen der Kantenlängen jedes Users zueinander und Speichern in einer Tabelle. Oder aber auch den gesamten Algorithmus in die Datenbank auszulagern.