Cookie Pattern

www.encodingchain.com

2009-08-08T13:40:00.000-07:00

encodechain.com was released today. A little tool which enables to combine various popular PHP conversion methods and to check how they affect your input... feel free to give me some feedback :)

Maybe someone could suggest a WebTwoOooo-Name for this service :P

bye bye version 4...

2008-08-08T10:30:00.000-07:00

Ten years ago Andi Gutmans and Zeev Suraski started to renew the old PHP3 core and in 1999 PHP4 was published and became really famous among Web-Developers.
Bute 5 years late the successor was published and since then everyone is wondering why the era of PHP4 will end.
Today is the magical 8-8-8 where PHP4 is no longer supported so for everyone who still runs PHP4 for some reason
YOU SHOW NOW REALLY HAVE A LOOK AT THIS PAGE: www.php.net/manual/en/migration5.php

Detailed history of PHP can be found on www.php.net/history

Working from home.

2008-07-15T10:26:00.000-07:00

There's so much work in this week that I can't publish a article in the next days.
But Natalie Jost from A List Apart just published a very nice article which you really should read if you're (like me) working from home read on.. ... you'll like it.

track time for a subroutine within a shell-script

2008-07-10T14:55:00.000-07:00

The following code-snippet is a shell-script which does the following:

Track the time for a block of shell commands
Check if the time was less than x seconds (the example uses 10 seconds)
If the block run through too fast the script waits/sleeps a few seconds
Run all this within a loop so that the block of shell-commands is executed periodically

I used the script combined with a PHP script which processes a queue. The PHP script processes 1000 elements from the queue and takes about 30 seconds for that. Since just having a cronjob per minute would be not efficient enought I used this script.
The waiting-block is necessary because now and then the queue is empty ... but I think there are lot's of situations where a script like this can be usefull:

#!/bin/bash
while [ 1 -ge 0 ]; do
time_begin=`date +%s`

###BLOCK 2 TRACK - BEGIN
number=$RANDOM
let "number %= 20"
sleep $number
###BLOCK 2 TRACK - END

time_end=`date +%s`
total=$((time_end-time_begin))

if [[ $total -ge 10 ]]; then
       echo "time taken was: $number : $total"
else
       echo "time take was too less  $number : $total"
       sleep 10
fi
done

Iterator [GoF]

2008-07-07T10:30:00.000-07:00

Lot's of people like to write down things into lists, so that they can go through that list later and check whether everything was fine. Normally every recipe has a list ~ there's always a list of ingredients at the beginning of the recipe.
This short example shows how such a list can be processed in PHP. So why would you want to have something else than a array to hold your objects? - My example still uses a array to hold the objects (uni- or bidirectional lists would also be possible) but it adds a kind of a facade to the array so that the common managements-tasks are handled within the List-Object. Everything you need for this example is present in PHP since version 5.0. The basic steps you need to do is to provide a "Object" and an "ObjectList" which implements the native "Iterator" interface and then you're able to have very handy lists :)

Show PHP Source Code

class Incredient {

    public $name,$amount;
    public function __construct($name,$amount) {
        $this->name = $name;
        $this->amount = $amount;
    }
}

class Recipe implements Iterator {
    public $title;
    private $ingredients;

    public function __construct ($title) {
        $this->title = $title;
    }

    public function addIncredient(Incredient $in) {
        $this->ingredients[] = $in;
    }

    public function current ()  {   return current ($this->ingredients);    }
    public function key ()      {   return key($this->ingredients);         }
    public function valid ()    {   return current ($this->ingredients);    }
    public function rewind ()   {   return reset ($this->ingredients);      }
    public function next ()     {   return next ($this->ingredients);       }
}

$cookieRecipe = new Recipe("Chocolate Cookie");
$cookieRecipe->addIncredient(new Incredient('Flour','2.5 cups'));
$cookieRecipe->addIncredient(new Incredient('Baking soda','1 teaspoon'));
$cookieRecipe->addIncredient(new Incredient('Salt','0.5 teaspoon'));
$cookieRecipe->addIncredient(new Incredient('Butter','1 cup'));
$cookieRecipe->addIncredient(new Incredient('Sugar','1 cup'));
$cookieRecipe->addIncredient(new Incredient('Brown Sugar','0.5 cup'));
$cookieRecipe->addIncredient(new Incredient('Vanilla extract','1 teaspoon'));
$cookieRecipe->addIncredient(new Incredient('Egg','1-2'));
$cookieRecipe->addIncredient(new Incredient('Chocolate chips','2 cups'));

// process recipe:
foreach($cookieRecipe as $inc) {
echo $inc->name." => ".$inc->amount." ";
}

As you see it's pretty easy to have lists of objects in PHP. You might also think that always creating to some list-object over and over again is very odd and you're right. For the most common tasks like iterating through arrays, directory-lists and a few more task you can use objects which are shipped with the Standard PHP Library ,which is also part of PHP since version 5 and mandatory in 5.3. So the example shown above could also look like this:

$recipe = array();
$recipe[] = new Incredient('Flour','2.5 cups');
$recipe[] = new Incredient('Baking soda','1 teaspoon');
$recipe[] = new Incredient('Salt','0.5 teaspoon');
$recipe[] = new Incredient('Butter','1 cup');
$recipe[] = new Incredient('Sugar','1 cup');
$recipe[] = new Incredient('Brown Sugar','0.5 cup');
$recipe[] = new Incredient('Vanilla extract','1 teaspoon');
$recipe[] = new Incredient('Egg','1-2');
$recipe[] = new Incredient('Chocolate chips','2 cups');

$recipeIncObj = new ArrayObject($recipe);
$ingredientsIt = $recipeIncObj->getIterator();

foreach($ingredientsIt as $inc) {
echo $inc->name." => ".$inc->amount." ";
}

As I said at the beginning, there are lots of situations where you might want to have a list for something and if you store that list in PHP the Iterator-pattern can keep your code clean and tasty :)

Null-Object Pattern

2008-07-01T10:58:00.000-07:00

Very often you create a object with a factory and before you really start using it, you check if your factory really created a object or returned NULL. Or maybe you have a method where a object is passed in and in this situation you'll have to do this check also.

Instead of typing the "if(object == null)" phrase again and again, you could use the Null-Object pattern, you'll see that this can make some situations much clearer.

Basically Null-Object ensures that the client always receives a valid object for it's interaction, so that there's no need to do the check shown above again and again. This happens since your concrete Null-Object just shares the interface, or inherits from the same class as it's effective counterpart, but it's implementation just leaves out any effectiveness.

So a code-example could look like this:

class CookieFactory {
    public function makeInstance() {
        if(date('l')=='Monday') return new NullCookie();
        return new RealCookie();
    }
}

interface iCookie {
    function getCalories();
}

class RealCookie implements iCookie {
    protected $calories=250;
    public function getCalories() {
        return $this->calories;
    }
}

class NullCookie implements iCookie {
    public function getCalories() {
        return 0;
    }
}

I think you can imagine what happens when you make use of the CookieFactory - diet on monday ;)

There're also some disadvantages, your clients normally don't have a chance to react that there's something special happening, also the clients must "share" the same expectation what "do nothing" means, the number of required Null-Objects might be very large and unhandy and the Null-Object shares a very deep knowledge with the real one, so that it might be a large effort to create it if the real object is complex too.

I'm so glad that today is tuesday :P

YSlow - powerful FF extension

2008-06-30T10:30:00.000-07:00

I use firebug for a while and I love it especially for CSS and JS debugging. Today I stumbled over Yslow and did some tests with it one some of my clients pages and I love the results.
YSlow can help you to analyze all the referenced elements on a webpage. It shows their sizes, how they behave when a page is taken from the browser-cache, shows optimization hints and enables a easy way to optimize the output of your dynamically created webpage :) ... you'll love it.
Get YSlow here :)

Factory [GoF]

2008-06-23T11:20:00.000-07:00

Do you remember the Façade pattern post? Sure you do :) - I described a child which asked his granny whether she could bake some cookies. So how this happens in a formal way was describe within the Façade pattern post ;) but the basic action "to ask for sth." is described here...

As you might remember we had a child, probably a lazy one, which was in the mood to eat some cookies but since the cookie tin was empty it asked his granny to bake some new. In OOP thats nearly the same - when you'd to have a (complex) object and if you don't already have one you need someone who creates it or you do it yourself but since you need remember all the steps to create it, that's something for programmers who likes to type :P

So normally you create a method which wraps up all the code to create the complex object. Or maybe you have a Aggregate and you don't want that everyone needs to know how it is build up then this method should be the only way to access the Aggregate.

You see now how you can benefit when you have a Factory available - but there are also some drawbacks. Factories tend to be hard to extend - this happens because the factory has a very deep (mostly hard-coded) knowledge of the objects it creates and normally all the wiring happens statically. If you're looking for a dynamic way to wire up your objects you might end making heavy use of reflection. In normal projects this might be a bit too much ;)

A normal factory method, for a cookie which requires to have 3 flavors, a predefined size and that it's baked before anyone consumes it, could look like this:

class Cookie { 

  // ... 

  /*
   * Create a Cookie object which consists
   * of 3 flavors and has a defined size.
   */ 
  public function getInstance() {
      $c = new Cookie();
      $c->setFlavor(Cookie::randomFlavor());
      $c->setFlavor(Cookie::randomFlavor());
      $c->setFlavor(Cookie::randomFlavor());
      $c->setSize(Cookie::randomSize());
      $c->bakeIt();
      return $c;     
  }

}

If your software contains some complexity where you want to switch the used objects (created by a factory) without modifying the clients, which make use of the factory, you'll end up with the so called Abtract factory.

Let's say you have two types of Cookies - the first one is a high-quality cookie with a bunch of different flavors and the second one is a normal chocolate-cookie. The high-quality cookie is created by your granny (slow but mind-blowing taste), the cookies with the lower quality are the result of mass-production. Your "client" is a wrapping machine which does everything to deliver the cookies to some customers.
So the wrapping machine won't care what kind of cookies are prepared for delivering and so it doesn't matter who the creator is - the only thing it has to know is how it can access the cookies... some kind of interface.
So the entire szenario could look like this:

class Cookie {

}

interface CookieFactory {
abstract function createCookie();
}

class Granny implements CookieFactory {
public function createCookie() {
$cookie = new Cookie();
// do some wierd cookie-creation stuff //
return $cookie;
}
}

class MassProduction implements CookieFactory {
public function createCookie() {
return new Cookie();
}
}

class wrappingMachine {
public function run(CookieFactory $factory) {
$i = 6;
$package=array();
while($i--) {
$package[] = $factory->createCookie();
}
return $package;
}
}

Client-code could look like this;

$wrapper = new wrappingMachine();
$highQualityCookiePackage = $wrapper->run(new Granny());
$lowQualityCookiePackage = $wrapper->run(new MassProduction());

Thats mostly what you can achieve with some normal Factories in the GoF-meaning. Some other interesting ways of object creation are the Plugin pattern and the Prototype pattern. :)

Query Object [PoEEA]

2008-06-20T10:29:00.000-07:00

Maybe you remember the Specification Pattern I explained some weeks ago. It enabled a easy and intuitive searching within large object-collections. A drawback of my example was that I stored the objects in the memory. This can be really ineffective if you want a single object out of hundreds, because you have to create all of them to see which one fits the specification.
Normally you want to limit the number of objects and you also don't store large datasets in memory. The idea of the Query Object pattern is that it enables a usage, comparable to the specification pattern, for objects which are persisted in a database. The benefit is that it creates a query to exclude objects which won't satisfy your needs and therefore you wont mess up the memory anymore.
Once you have a query-object in place you should not get in touch with SQL anymore because it can encapsulate SQL completely, at least if you also have some kind of data mapping (coming soon), which is a great benefit for everyone who is not so familiar with SQL. (But don't forget, regarding performance, SQL-optimization is a very important thing).

So what we need for the Query Object in first place is a object, I'll use the Cookie out of the specification pattern post again. Then we need criteria-objects which hold the information for a single criteria, (determined by "database-field", "operator" and "value") and we also need the Query Objects itself to wrap up the SQL-querying and the object creation somehow.

A very simple example could look like this:

Show PHP Source Code

interface Critera {
public function getWhereClause();
}

class CookieCriteria implements Critera {

private $operator,$field,$value;

protected function __construct($operator,$field,$value) {
$this->operator=$operator;
$this->field=$field;
$this->value=$value;
}

public function getWhereClause() {
return implode(" ",array($this->field,$this->operator,$this->value));
}

public static function matches($field,$value) {
return new CookieCriteria("LIKE",$field,'"'.$value.'"');
}

public static function greaterThan($field,$value) {
return new CookieCriteria(">",$field,$value);
}
}

class CookieFinder {
protected $criterias;

public function addCriteria(Critera $criteria) {
$this->criterias[] = $criteria;
}

public function generateSQL() {
$sql = "SELECT * FROM cookies";

if(sizeof($this->criterias)) {
$where=array();
reset($this->criterias);
while(list(,$criteria)=each($this->criterias)) {
$where[] = $criteria->getWhereClause();
}
$sql.= sizeof($where)?" WHERE ".implode(" AND ",$where):"";
}
return $sql;
}

public function find() {
$collection = array();
if(!$result = mysql_query($this->generateSQL())) {
throw new Exception(mysql_errno());
}
while($row = mysql_fetch_assoc($result)) {
$collection[] = new Cookie($row['name'],$row['flavor'],$name['size']);
}
return $collection;
}
}

Possible client code could look like this:

$finder = new CookieFinder();
$finder->addCriteria(CookieCriteria::matches("name","Granny%"));
$finder->addCriteria(CookieCriteria::greaterThan("size",100));
$cookies = $finder->find();

We just pick up the Query Object, add one or more criteria and ask it to create the objects which fit them.

So this example is not as powerful as the one I used for the Specification pattern, but it should be a easy task to create some kind of "nested criteria objects".
Query objects normally make use of data-mapping so that you can handle various classes, stored in different tables/databases, with a single and generic Query Object. This also enables to avoid SQL-Injection, since you're able to validate the fields and values before you sent them to your database, also some kind of database abstraction would be possible.
With the "Query Object by example", which requires to build up a single object which is used as blueprint for the required objects, exists another flavor of this pattern which is very handy to use and more descriptive.
But no matter which flavor you prefer, Query Objects bring some real benefits when you've to handle complex datasets - for smaller projects the effort might be to much so be careful where you use it.

Façade [GoF]

2008-06-16T16:33:00.000-07:00

If a child is in the mood to eat a fresh cookie it normally asks his granny for one. Like this:

Child: Grannyyyyy?
Granny: Yes my dear?
Child: Could you mix about 2 cups of sugar, 1/2 cup of butter and 1/2 cup of milk in a saucepan and boil it for a minute. And could you, after you removed the saucepan from the heat, mix in some cocoa powder and 3 cups quick cooking oats and form some cookies? Pleeease?

Hm you're right that's not very realistic - it's more like: "Grannyyyy? Could I have a cooookieee pleeeease?" ....the granny knows what to do and the child will get it's cookie

So what happens if you have a pice of software which provides ~~cookies~~ some services for other parts of your software? The most people (especially programmers) are lazy and they won't remember all the details of a complex structure. They remember the place or object which can run a certain task but there's no need to know the deeper structure of that object - the only thing which is important if your using a service of an object is that it doesn't fail.
So the Façade pattern is a structural pattern which more or less describes that you create a object with an simplified interface, so that you can hide complex structures. You can also use a Façade to wrap up some poorly designed APIs into a single well designed API. And the larges benefit of a Façade object is that it makes APIs more readable and therefore enables flexible and easy development.

So maybe you're missing the example-code for this pattern, but since it's not that concrete as others, I've not implemented a special example for it. But I already used a Facade in some way, if you look at the Specification pattern, you'll find the functions getSmallChocolateCookies() and getLargeCookies(). Both show in a tasty way what I described here :)

Inherit abstract functions....

2008-06-11T13:28:00.000-07:00

A error I find from time to time when I work with inheritance is this one:

Fatal error: Can't inherit abstract function Cookie::setFlavor() (previously declared abstract in ChocolateCookie) in ...

This happens when you try to define multiple abstract classes or interfaces with the same abstract functions - it's right that this errors shows up, but today I stuck on this error for a while because I did not see the reason for that - so that's a reminder for me ;)

And the tasty example to reproduce this error:

abstract class Cookie {
abstract public function setFlavor($flavor);
}

abstract class ChocolateCookie extends Cookie {
abstract public function setFlavor($flavor);
}

There are also some rejected bugreports about that :P #35057 #35832 #41145

new TYPO releases

2008-06-11T07:18:00.000-07:00

I just saw that the TYPO3 guys released a new version of the popular Enterprise CMS (www.typo3.org). The changelog shows that they mainly changed some security issues and that a lot of smaller changes in the backend happend - one change relates to the problems in the new Firefox 3 where all the frames in the backend are mixed up for some compatibility reason... this was also the reason why the also updates the 4.0.x branch and the 4.1.x branch ...

TYPO3 source package downloads / TYPO3 upgrading guide

www.cookiepattern.com

2008-06-09T09:52:00.000-07:00

To keep my motivation high I just registered www.cookiepattern.com - so for today this was $1 per visitor :P

Self-extracting PHP archive

2008-06-07T14:30:00.000-07:00

The __halt_compiler(); function in php enables to store some additional data in a php-file without blowing up the memory. A very nice possibility is to use this for a self-extracting php file as installation-packages of your php application.
A wile ago I created a script which automatically creates such a archive and I think you might like it....for the impatient ones: Download / Download as Zip.

Before I start to show how the entire script works I'd like to show you a small example so that you can see how the __halt_compiler(); function can be used to store some data at the end of a file:

<?php

$fp = fopen(__FILE__, 'r');
fseek($fp, __COMPILER_HALT_OFFSET__);
$i=0;
while($buffer = fgets($fp)) {
echo ($i++). ":". $buffer." ";
}
;
__HALT_COMPILER();Line 1
Line 2
Line 3
Last line

The first thing you might mention is, that the closing "?>" is missing, but since the function-name is nearly self-explaining you should realize very fast what the output of the script might be ;)

If that's working the question is what's needed for a script which is meant to create and extract a archive? The first thing is a way to create the archive itself. I used the PHP-builtin ZipArchive for that. The second thing is a script which is able to extract this archiv (using the method show above). That's handled by the following snippet:

<?php

try {
 $zipfilename = md5(time()).'archive.zip'; //remove with tempname()
 $fp_tmp = fopen($zipfilename,'w');
 $fp_cur = fopen(__FILE__, 'r');
 fseek($fp_cur, __COMPILER_HALT_OFFSET__);
 $i=0;
 while($buffer = fread($fp_cur,10240)) {
 fwrite($fp_tmp,$buffer);
 }
 fclose($fp_cur);
 fclose($fp_tmp);
 $zipfile = new ZipArchive();
 if($zipfile->open($zipfilename)===true) {
 if(!$zipfile->extractTo('.')) throw new Exception('extraction failed...');
 } else throw new Exception('reading archive failed');
 $zipfile->close();
 unlink($zipfilename);
} catch (Exception $e) {
 printf("Error: %s %s>",$e->getMessage(),$e->getTraceAsString());
};
__HALT_COMPILER();[zipdata is appended here later]

As you see that's no rocket-science just read the data, pass it to the ZipArchive object via a temporary file and extract the archive.
If that's working then you need a script which brings the PHP extraction script and the zip-data together. And since we want to have a single script for the creation of our self extracting php archive, it would be very odd if we'd place the "template" for the extraction in a separate file. That's the reason why I just use the same method as above for this script and this time the data is php code instead of zip-data:

<?php

try {
 $sourcefolder = 'compressthis/'; // maybe you want to get this via CLI argument ...
 $targetname = 'phparchive.php';
 $zipfilename = md5(time()).'archive.zip'; // replace with tempname()

 // create a archive from the submitted folder
 $zipfile = new ZipArchive();
 $zipfile->open($zipfilename,ZipArchive::CREATE);
 addFiles2Zip($zipfile,$sourcefolder,true);
 $zipfile->close();

 // compile the selfextracting php-archive
 $fp_dest =fopen($targetname,'w');
 $fp_cur = fopen(__FILE__, 'r');
 fseek($fp_cur, __COMPILER_HALT_OFFSET__);
 $i=0;
 while($buffer = fgets($fp_cur)) {
 fwrite($fp_dest,$buffer);
 }
 fclose($fp_cur);
 $fp_zip = fopen($zipfilename,'r');
 while($buffer = fread($fp_zip,10240)) {
 fwrite($fp_dest,$buffer);
 }
 fclose($fp_zip);
 fclose($fp_dest);
 unlink($zipfilename);

} catch (Exception $e) {
echo $e->getTraceAsString();
}

function addFiles2Zip(ZipArchive $zip,$path,$removeFirstFolder=false) {
 $d = opendir($path);
 while($file = readdir($d)) {
 if ($file == "." || $file == "..") continue;
 $curfile=($removeFirstFolder)?substr($path.$file,strpos($path,'/')+1):$path.$file;
 if(is_dir($path.$file)) {
 $zip->addEmptyDir($curfile);
 addFiles2Zip($zip,$path.$file.'/',$removeFirstFolder);
 } else {
 $zip->addFile($path.$file,$curfile);
 }
 }
 closedir($d);
}

__HALT_COMPILER();[the script shown above]

If you all wrap up into a single script the you'll have something like the script I already mentioned.
I think that it could be useful to have a version with a better error-handling and maybe also some CLI functions so that there's no need to edit the script itself everytime... I'll keep you updated as soon as I have something like that :)

Plugin [PoEAA]

2008-06-04T18:11:00.000-07:00

I'm sure you're pretty often in the situation that you have to switch something depending on the context you're currently in. For example most people change their eating habits before summer - I also do :P

Sometimes this is what you also want to have in your software. To achieve different behaviour you normally just implement two different classes or aggregates and since they have the same "meaning" they normally share a interface (a.k.a Separated Interface). But who decides which implementation fits into the current environment/context?

The easiest way is to have a Factory Method with a small condition to decide this, but this method might grow very fast if you have various options. In this situation its also a matter of form to move this decision into some kind of configuration(-file) so that there's only on file which differs in various environments.

Martin Fowler suggests to place some kind of mapping into the configuration-file, so that your Factory knows which implementation to instantiate in the current context. The key for the mapping in this case is the name of the Separated Interface.

As you see in the example code below, there are Cookie Tins which ~~create~~ contain Cookies and depending on the current month you want to use a more or less restrictive Cookie Tin. In May, June and July you restrict your application to create max. 5 cookies, the rest of the year you don't care :P

Show PHP Source - Main Classes

// The Separated Interface
interface CookieTin {
public function getCookieInstance();
}

class NormalTin implements CookieTin {
public function getCookieInstance() {
return new Cookie();
}
}

class DietTin implements CookieTin {
protected $i=0;
public function getCookieInstance() {
return ($this->i++ < 5)?new Cookie():new NullCookie();
}
}

// The Factory which supports Plugin-Creation
class CookieTinFactory {
public static function getPlugin( $class ) {
try {
return new $GLOBALS['Plugins'][$class]();
} catch( Exception $e) {
// maybe call some default implementation if the mapping is wrong
}
}
}

Show PHP Code (less important part)

class Cookie {
public function printCalories() {
echo '200 ';
}
}

class NullCookie extends Cookie{
public function printCalories() { }
}

Show PHP Client Code

// This is usually in a configuration-file, normally this should
// also sit in a XML structure....

// That's what it would be in 300 days/year
$GLOBALS['Plugins']['CookieTin'] = "NormalTin";
// That's what we have to turn it to before summer :P
if(in_array(date('n'),array(5,6,7))) {
$GLOBALS['Plugins']['CookieTin'] = "DietTin";
}

$tin = CookieTinFactory::getPlugin('CookieTin');
$i=10;
while($i--) {
$cookie = $tin->getCookieInstance();
$cookie->printCalories();
}

A very common use-case for this is the changed behaviour in a testing-environment compared to the production-environment.
There's something else in the example beside the Plugin Pattern - I also made use of the Special Case (the NullCookie) pattern which I'm going to show in a future post....

Comparing PHP Best Practises

2008-06-02T08:37:00.001-07:00

If you're still wondering whether the single- or double quotes are processed faster in PHP you might want to look at phpbench.com. They don't provide any ground breaking new insights, but they show in a very nice way what's best pratice when it comes to arrays, strings and loops...

Value Object [DDD]

2008-05-29T21:39:00.000-07:00

This metaphor does not fit completely, and the "Money-Example" is omnipresent, but I really like the pattern and so that's the story:

Let's say you have your grannies recipe for a chocolate cookie and you want to keep this in mind, but also you like to somehow experiment with some new or different ingredients. Normally you just keep in mind what you changed and later you write down the new recipe. But from time to time you might want to compare the two recipes or maybe you want to make cookies with the new and the changed recipes. In this situation it's really good to have both written down on paper. ;)

In the world of OOP you could think of a solution using the Memento-Pattern but this doesn't really fit the situation and it's also some kind of overhead. That's the reason why the Value Object is the pattern of my choice.

So let's look at the recipes again - we want to add and remove ingredients without modifying the original recipe and we want to compare the resulting recipes. We don't need to track a special identity of our recipes since we're only "collecting" ingredients.

The idea of the Value Object is that every every method which somehow transforms the state of a object always returns a new object and the old object stays untouched. Whenever needed you should also implement a method to compare objects, I must concede that the common "Money Example" shows much better when that's needed ...

Another edge of this pattern in PHP is that you can use method-chaining to perform multiple actions within a single line of code. So just have a look at the example you will like it's taste :)

Show PHP Source Code

class Recipe {
protected $ingredients;

public function __construct($ingred='') {
$this->ingredients = implode(',',array_unique(explode(',',$ingred)));
}

public function addIncredient($ingred='') {
return new Recipe($this->ingredients.','.$ingred);
}

public function removeIncredien($ingred='') {
return new Recipe(preg_replace('/,{0,1}'.$ingred.',{0,1}/','',$this->ingredients.','));
}

public function printIncredients() {
echo str_replace(',',' ',$this->ingredients);
}

public function equals(Recipe $recipe) {
return (strcmp($this->ingredients,$recipe->ingredients)===0)?true:false;
}
}

Show PHP Client Code

$granniesRecipe = new Recipe('flour,baking soda,sugar,salt,butter,vanilla,chocolate');
$aNewRecipe = $granniesRecipe->addIncredient('lemon');
$coconutRecipe = $granniesRecipe->removeIncredien('chocolate')->addIncredient('coconut');

// check if that worked:
echo ' Grannies Cookie Recipe - Incredients are: ';
$granniesRecipe->printIncredients();
echo ' A new Cookie Recipe could look like: ';
$aNewRecipe->printIncredients();
echo ' A coconut cookie would look like: ';
$coconutRecipe->printIncredients();

The implementation is a bit odd, since it only collects the names of the ingredients but not the amount, but including the amounts of incredients would not change the concept and that's why I left it out. I hope you got a idea how the pattern works - the main thing is that there's no identity and that new objects are instantiated as soon as the state of the old one would change.

Prototype [GoF]

2008-05-27T16:17:00.000-07:00

Imagine a cookie-oven which produces tasty cookies with chocolate crumbles. How do you ensure that the 1000th cookie still has the same taste as the first?
You might think that this is an easy task - just write down the recipe and follow the described steps...you know the result in real life - the 1000th cookie normally tasts like the 1st but you always had the "overhead" to read the recipe and go through the steps again and again.
In OOP it's much easier to follow the recipe just instantiate a new Object and there you go... no matter if it's the 1st or the 1000th - it'll always ~~taste~~ look similar.
But the "recipe-overhead" is still there in a way and especially when you have larger objects whose construction is time-consuming you might want to somehow get rid of it. And that's where a Prototype can help you out - you just create the first ~~Cookie~~ Object and then you use the handy magic method __clone to create new objects.
Instead of just using __clone the pattern suggests a class (some kind of a factory-class) so that you can also encapsulate the creation of the objects (and also possible adjustments you might want to make after the creation/clone).

So the example just shows a cookie-machine which makes use of the prototype-pattern to create new cookies (depending on the cookie you throw in before)... yummy

Show PHP Source Code

abstract class Cookie {
function __clone() { }
abstract public function printFlavor();
}

class CoconutCookie extends Cookie {
public function printFlavor() {
echo 'Coconut Flavor ';
}
}
class ChocolateCookie extends Cookie {
public function printFlavor() {
echo 'Chocolate Flavor ';
}
}

class CookieMachine {
protected $cookie;
public function __construct(Cookie $cookie) {
$this->cookie = $cookie;
}
public function makeCookie() {
return clone $this->cookie;
}
}

The client-code can look like this:
Show PHP Sample Code

$coconutCookie = new CoconutCookie();
$coconutCookieMachine = new CookieMachine($coconutCookie);

$chocolateCookie = new ChocolateCookie();
$chocolateCookieMachine = new CookieMachine($chocolateCookie);

//while(true) {
for($i=0;$i<5;$i++) {
$coconutCookieMachine->makeCookie()->printFlavor();
$chocolateCookieMachine->makeCookie()->printFlavor();
}

PHP FastCGI vs. PHP as a module

2008-05-24T10:40:00.000-07:00

The apachelounge.org guy published a very interesting stat which compares the memory-usage of PHP/FastCGI and PHP/as module and that's really interesting:

There's no comment about performance and in early versions FastCGI/PHP was a bottleneck but maybe these days are gone :)

Singelton [GoF]

2008-05-23T14:40:00.000-07:00

So this pattern is a very well know and a often discussed one.

Explaining it the tasty way: let's say you have exactly one well know place where you store all your cookies and whenever you need one you can easy point to that place. Normally that's really comfortable because whatever you do with it, you don't have to search some place where you can find a cookie, you just go to that single "cookie tin" (or wherever you store cookies) and put a new cookie into it ;)

In modern OOP the singleton is not very popular, Eric Evans simple calls it anti-pattern. It makes it much harder to test your software and normally the user of the class, not the class itself, should know how many instances are needed.

But nevertheless for small applications it's very comfortable to use it in some situations and as long as you're also familiar with the drawbacks I think it's ok to consider using it....

So the example shows a cookie tin and how to use it and by the way it also implements some kind of lowlevel registry by using the PHP5 magic methods, but that's another story ;)
Show PHP Source Code

/**
* CookieTin a.k.a Singleton object
* we what to force our application

* to hold exactly one CookieTin object
*
*/
class CookieTin {
private $_cookies=array();

/* generic singleton part start*/

private static $_instance=NULL;
// prevent instatiation from the outside
private function __construct() { }

// prevent cloning
private function __clone() {}

public static function getInstance() {
if(!self::$_instance) {

self::$_instance = new self();
}
return self::$_instance;
}
/* generic singleton part end */

/* registry part start */
public static function __set($key,Cookie $value) {

echo "call setter\n";
self::$_instance->_cookies[$key] = $value;
}

public static function __get($key) {
echo "call getter\n";
return self::$_instance->_cookies[$key];

}

public static function __isset($key) {
echo "call isset\n";
return isset(self::$_instance->_cookies[$key]);

}

public static function __unset($key) {
echo "call unset\n";
unset(self::$_instance->_cookies[$key]);

}
/* registry part end */
}
/**
* Dummy Cookie
*/
class Cookie {
public $name,$flavor;

}

Show PHP Client Code

$tin = CookieTin::getInstance();
if(!isset($tin->granniescookie)) {
$tin->granniescookie = new Cookie();

$tin->granniescookie->name="Grannies chocolate wonder";
$tin->granniescookie->flavor="chocolate";

}

CookieTin::getInstance()->granniescookie->flavor = "chocolte chips";

var_dump($tin);
unset(CookieTin::getInstance()->granniescookie);
var_dump($tin);

The really important things happen in the last lines where the CookieTin is accessed statically and this change also (as you will see yourself) is reflected in the local instance if the $tin.

PHP sucks? not really!

2008-05-21T23:35:00.000-07:00

There are so many people from outside of the PHP World and lots of them are complaining about PHP and their reasons are mostly so ridiculous. In most cases they just say that PHP code sucks.
The PHP 10.0 Blog brought up some good arguments about that and I fully agree - it's not the language that produces sucking code, it's the guy who wrote it down. Click

error_reposting and exceptions....

2008-05-20T14:40:00.000-07:00

I just found this line:

set_error_handler(create_function('$x, $y', 'throw new Exception($y, $x);'), E_ALL~E_NOTICE);

in the comments on php.net and did a short test to see whether it works. Normally I used to have a global function which passes all the errors through a logging-chain (FILE/MAIL/DISPLAY) but having exceptions could be more comfortable because you might sometimes want to make decisions locally and not on a global scope and just setting and re-setting the error-handler is not the best idea for this... I'm not sure if I get used to it, because the error-handling function did a good job for the last years ... we'll see :)
So that's the full example code:

set_error_handler(create_function('$x, $y', 'throw new Exception($y, $x);'), E_ALL);
try {

$errors = array(
E_USER_WARNING => "something might be wrong",
E_USER_NOTICE => "it works but I don't like it",
E_USER_ERROR => "something went completly wrong",
);

// echo $name; //should cause a E_NOTICE

foreach($errors as $code=>$msg) {
try {
trigger_error($msg,$code);
}
catch (Exception $e) {
if(!in_array($e->getCode(),array(E_USER_WARNING,E_USER_NOTICE))) {
throw $e;
}
else {
// not a big deal we can push this into a log-file and continue or work...
echo "local exception: (".$e->getCode(). ") ".$e->getMessage()." ";
}
}
}

}
catch (Exception $e) {
echo "global exception:".$e->getMessage()." ";
}

Preview to PHP 5.3

2008-05-18T22:15:00.000-07:00

One of the mayor updates since PHP 5.0 is upcoming with the 5.3 version, this is also a major step forward to PHP 6 - I love to have namespaces and appreciate the split of E_NOTICE and E_DEPRECATED. Also other features like the native MySQL support ( I hope this really raises the performance), the array_replace/array_replace_recursive functions and also dynamic calls to static functions "$classname::$functionname($parameter);" sound very cool. So I really look forward to have it on the server (or at least on my laptop) :P

Regarding the namespaces I've one idea: maybe someday someone will invent a common namespace "php::clean" which fixes all the small inconsistencies within function-names and parameter-styles ... that would be really great ;)

A nice article with a more detailed look into namespaces and the other inventions in 5.3 can be found on sitepoint.com

Firefox 3 RC1

2008-05-18T09:11:00.000-07:00

I just saw that the first Release Candidate of Firefox 3 is available for download . As with the most of the Beta-versions I also checked this update because I'm really excited to get the new features, but after 5 minutes (again) I removed it from my PC. Non of my extensions is working in FF3 (except the dictionary), it still destroys the Frames in TYPO3 (there's a bugfix-extension for that) and the memory-usage is still very high,10% lower than in FF2 but still high.
So I postponed the update and kept on running Firefox 2, at least until the next Release Candidate ;)

Using Mocks within Tests

2008-05-17T13:02:00.000-07:00

Let's say you have some kind of process which creates cookies and which requires the cookies to bake before you deliver them to the customers. This process somehow touches two kinds of objects the cookie itself and a object which performs the process - the cookie oven.
When you start to develop the oven how do you check whether the cookies are really baked or not? Since you can't get rid of the dependency between the oven and the cookie, you have to simulate a real object and do the checks by hand - but wait there's already a way to resolve it:
PHPUnit ships with a very nice and comfortable function to create and check mock-objects and that's exactly what we need in this situation where we somehow need to find out if our cookie really gets baked.
The testcase for this scenario could look like this:

class TestCookieOven extends PHPUnit_Framework_TestCase {
public function testIfCookieIsBakenWithinFinishing() {

/* create the mock and expect the
bakeIt method to be called at least once */
$cookiemock = $this->getMock('Cookie', array('bakeIt'));
$cookiemock->expects($this->once())->method('bakeIt');

/* create the observed object and perform the required steps */
$cookieoven = new CookieOven();
$cookieoven->finishCookie($cookiemock);
}
}

This first creates a mock and assigns the expectation that the "bakeIt"-function is called exactly once. [ beside the ->once()-call there are some alternatives: ->any(), ->never(), ->atLeastOnce(), ->exactly(int $count) and ->at(int $index) ]. Then it passes the mock to the oven and performs the method we want to check. To make this test green you need at least this:

CookieOven {
/**
* Takes a cookie and prepares it to be ready
* for a customer
*
* @param Cookie $cookie
*/
public function finishCookie(Cookie $cookie) {
$cookie->bakeIt();
}
}

So as soon you have these lines you have a green test and that's great because there is no need to have a real "cookie" class - someone else can take care of the cookies - oh wait ... I'd better do this myself :P