Working from home.

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

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

1. Track the time for a block of shell commands
2. Check if the time was less than x seconds (the example uses 10 seconds)
   
3. If the block run through too fast the script waits/sleeps a few seconds
4. 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]

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."<br/>";
}

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."<br/>";    
}

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

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