Behat is a relatively new testing tool and is centred round the Behavioural Driven Development methodology.

The workshop will consist of an introduction followed by a number of practical exercises. By the end of the workshop attendees will be able to write and execute Behat tests and should be ready to use Behat in their projects.

In order to gets the most out of the session I’ve asked attendees to set up LAMP and Behat before hand.

Heres What you need:

NOTE: If you are unable to meet these set up requirements I will be running a ‘Behat Setup Clinic’ on Friday. Follow me on Twitter for details.

1) Apache (pref with new VHOST Set up).
2) PHP 5.3 (Command line and Set up with Apache)
3) Behat (runnable from the command line)
– Behat Quick Start
4) Java (required for Sahi)
– Java Install
5) Sahi
– Sahi Install

This seems like a lot of set up but in reality I expect most attendees working with PHP to have much of this set up already.

I look forward to seeing you at my workshop!

It was suggested that one way in which to get round this is to move your libraries to Azure blob storage. This isnt a supported solution but I thought I’d give it a go. At the moment it takers roughly 40 min to package my application and then upload it to Azure. Note: These are just initial experiments. The process outlined below doesn’t work yet (although it’s pretty close)!

Blob storage is almost a flat file system. It’s laid out in the following format:   account>>container>>blob.

By contrast most libraries have a very nested structure. In my example I’ll use Zend Framework. The class Zend_Log_Writter is stored in the file:   lib >>Zend >> Log >> Writer.php

The first logical step is to flattern the library into a single folder using periods to denote the previously nested structure of the files. EG: Zend.Log.Writter.php would be the name of a blob stored in the container ‘zend’. I achieved this using a simple command line script using php and the SPL iterators.

$args = $_SERVER['argv'];
 
$source = $args[1];
$dest = $args[2];
 
$rSourceDir = new RecursiveDirectoryIterator($source);
 
$rSourceDirItr = new RecursiveIteratorIterator($rSourceDir);
 
$transArray = array();
 
foreach($rSourceDirItr as $key => $file) /* @var $file SplFileInfo  */
{
 
    $realPath = $file->getRealPath();
 
    $flatPath = flatFileName($realPath);
 
    $destination = $dest . DIRECTORY_SEPARATOR . $flatPath;
 
    copy($realPath, $destination);
 
}
 
function flatFileName($path)
{
    $pos = strpos($path, 'Zend');
 
    $path = substr($path, $pos);
 
    $path = str_replace(DIRECTORY_SEPARATOR, '.', $path);
 
    return $path;
}

The script takes two arguments: the source (nested library directory) and a destination directory (for the flattened structure).

After this process it’s worth inspecting the flat folder to ensure the results are consistent to what you expected. After this I used a similar script to upload the files to Azure Blob Storage.

include 'conf.php';
 
// Set up Microsoft Azure SDK Autoloading
 
set_include_path(get_include_path() . PATH_SEPARATOR . AZURE_SDK);
 
require_once 'Microsoft/AutoLoader.php';
 
Microsoft_AutoLoader::Register();
 
$storageClient = new Microsoft_WindowsAzure_Storage_Blob(AZURE_HOST, AZURE_ACNAME, AZURE_PACCESS);
 
// Check Args are in order
 
$args = $_SERVER['argv'];
 
if(!isset($args['1']) || !isset($args['2']))
{
    die('invalid arguments supplied' . "\n");
}
 
$source   = $args[1];
$destCont = strtolower($args[2]);
 
if(!is_dir($source))
{
    die('source is not file');
}
 
if(!$storageClient->containerExists($destCont))
{
    $storageClient->createContainer($destCont);
}
 
// Folder should be flat
$recSourceDir = new RecursiveDirectoryIterator($source);
 
foreach($recSourceDir as $file)
{
    $storageClient->putBlob($destCont, $file->getFileName(), $file->getRealPath());
    echo "PUT - " . $file->getFilename() . "\n";
}

This is likely to take some time as each file is uploaded individually.

The next step in the process is to set up an autoloader to get required files from Azure.

class Flat_Autoloader
{
 
    /**
     * Blob Storage Class
     *
     * @var Microsoft_WindowsAzure_Storage_Blob
     */
    private static $blob;
 
    /**
     * Registers the autoloader
     */
    public static function Register($blob)
    {
        self::$blob = $blob;
        self::$blob->registerStreamWrapper('blob');
 
        return spl_autoload_register(array('Flat_AutoLoader', 'Load'));
    }
 
    /**
     * Load a class
     *
     * @param string $className Class name to load
     */
    public static function Load($className)
    {
        // Get the file name from the class name.
 
        $partArray = explode('_', $className);
 
        $containerName = trim(strtolower($partArray[0]));
 
        $flatClass = implode('.', $partArray) . '.php';
 
        echo $containerName . " " .  $flatClass;
 
        if(!self::$blob->blobExists($containerName, $flatClass))
        {
            return false;
        }
 
        require_once('blob://' . $containerName . '/' . $flatClass);
 
    }
 
}

The class takes an instance of the Azure Blog storage class from the Windows Azure SDK and on registration of the autoloader ensures that the ‘blob’ stream is available for future use. In the Load method the incoming class name is exploded and the first part of the class name (‘Zend’) is used as the container to look for the class file in. The blob name is the imploded class name (with ‘.’ substituting any instances of ‘_’).

The container / blob combination is the required.

Caveats

There are two main caveats to using this approach to autoload files on Azure.

1) The included files may not themselves use require / include statements as these will fail. This article outlined a method for removing all the require_once calls from Zend Framework.

As the blog above mentions there is one require_once statement in Zend_Application that cannot be removed. After initially trying to override methods in Zend Application that trigger Zend_Autoloader I gave up. I think inheriting from Zend Application and Zend_Application_Bootstrap_Bootstrap then overriding the relevant methods is possible but is a project for the future.

% cd path/to/ZendFramework/library

% find . -name '*.php' -not -wholename '*/Loader/Autoloader.php' \
-not -wholename '*/Application.php' -print0 | \
xargs -0 sed --regexp-extended --in-place 's/(require_once)/\/\/ \1/g'

2) Requiring a file from blob storage has a particularly high performance penalty as it is done over http. The next logical step is to use  a byte code cache like APC or the Azure equivalent Win Cache to ensure that after an initial load the file is not recalled from blob storage again.

Today I decided to put on my war paint and become a man. I’m building and MVC PHP Framework called the Edu Framework (Edu – get it?).

As I have mainly used the Zend Framework in the past I imagine that it will look like a very basic version of Zend Framework with a Front Controller, Action Controllers, Request / Response Objects and a view. The fun part is that I’ve decided to not look under the hood of the Zend Framework until I have reached version 1.0 of Edu. Instead I will rely of Martin Fowler’s – POEAA , The Gang of Four and the many articles written about the famous MVC implementation on the net.

In addition to building the framework I have also set myself the task of achieving a high Joel Test Score. Although I already use source control I will have to learn how to unit test, create a deployment process, a bug tracker and put in place a myriad of other techniques Joel mentions in his infamous article.

Tonight’s work consisted of setting up the project environment (installing Ubuntu, LAMP, SVN, PHP Unit and Xdebug). Over the weekend I’m going to come up with a rough UML design of the framework and post it. I will also create a project bug tracker.

Finally in addition to hopefully learning more about PHP and software development my ultimate goal is to have a presentation to give at the unconference at the Dutch PHP conference. If your planning to attend this year I hope you’ll drop by.

There were some truly excellent sessions at the conference, good mix of technical presentations and more abstract sessions on emerging technologies and management.

I arrived in Antwerp on Friday with Roan Merewood (who’s talk I unfortunately did not manage to attend), we went our separate ways at the conference Hotel and I checked into my own Hotel and created the first video blog post. I later attended the social in Antwerp itself, although a little far away from the conference venue it was nice to meet with the speakers and organisers on a informal basis.

The first session I attended was “Dependancy Injection in php 5.3” by Fabian founder of the Symphony project. It was a good talk, he started with the real basics of dependency injection and quickly scaled this up to a trivial example and then went on to implement a very impressive DI container in just 40 lines of code. What made his talk even more interesting was the use of two PHP 5.3 features, lambda functions and closures. I’d never seen these features demonstrated before and will certainly check out his code and play with it.

After this I stayed in the main track for “The Sate of SOAP” with David Zuelke. I liked David’s approach, he again outlined the real basics of SOAP first and continued to highlight the more advanced features such as class mapping I’d never used before. He also introduced me to automatic WSDL creation and gave tips on how to overcome some of the common pitfalls you might encounter when trying to expose more complex methods over soap.

Moving into track two after lunch I attended Kore Nordmann’s “Couch DB, PHP and PHPillow” presentation. With no previous experience in non relational databases I found this talk interesting, but a little hard to follow. To understand more I think I will have to download his slides and experiment a little. One concept I did find quite interesting is that it has an almost entirely restful interface. This means you can communicate with the database purely via HTTP.

After sitting on the couch with Kore I stayed in track two for Ivo Jansch’s “PHP & The Cloud”. This was a good introduction to the three main cloud solutions ranging from IaS (Infrastructure as a service), PaS (platform as a service) and SaS (software as a service). He highlighted the fact that at the moment the cloud is perceived mostly as a fad with few people utilizing it to it’s full potential. However in the next three years this is likely to change rapidly. Deploying on the cloud will become the de facto standard and as developers, to stay in the game we must take steps to prepare for this.

I left Ivo’s talk knowing more about the types of cloud solutions available but more importantly with a mind to develop new code with an eye to scalability. I’ll be downloading his slides to look at before starting my next project to get back into this mindset and to look at the some of the solutions he proposed.

Interestingly the next talk was given remotely, with no speaker on the stage. Eric Ritchie was unable to make the conference due to the snow that had fallen over night. Luckily he already had the tools in place to deliver his content remotely. I had been particularly looking forward to this subject as PDF generation is such a difficult thing to do well. He proposed a fairly simple solution using Zend Framework (and Zend View) with Java Bridge. He used Zend View to create templates with a special form of XML, it looked quite simple during the talk. I hope it is easy to replicate his methods when I attempt this in the future.

The closing keynote was given by Cal Evans. I was a little dubious when he mentioned his talk would be primarily aimed at managers and team leaders. These fears were soon allayed however when he started talking with real passion about ‘open teams’. He took many of the qualities that make open source projects so inspiring to work for and showed how they could be adapted to fit into a corporate or business settings. His key message boiled down to (paraphrased):

“Developers want three things, respect, ownership and credit of their work and to maintain a good work life balance. By giving them these things you can increase the return on investment of your development team incredibly”.

I found his comments so insightful that I will remember them when looking for my next work place and implement them in the future should I be given the opportunity to lead or manage a team. Thanks Cal!

The conference social was probably the best conference social I have attended so far (including the one at DPC – which rocked!). The drink flowed freely courtesy of Ibuildings (thanks guys!), the food was really nice and the party culminated in some bowling. Jeremy (@phpcodemonkey) was good enough to show me how to improve my technique considerably.

The party finished at around 12pm, and I called a taxi and went back to my hotel. I then slept for ten solid hours.

AT the end of every conference I attend I make some resolutions on what steps to take to ‘up my game’ before attending the next one. Conferences tend to leave me with a feeling that I need to ‘Up my game’, PHP Benelux was no exception:

Conference Resolutions

• Start Unit Testing!
• Install Xdebug
• Experiment with continuous integration (long term)
• Download the slides on Soap, Open teams, Dependency Injection and Cloud Computing. Also link up all me colleges who may find this info useful.

I’d like to take this opportunity to thank all the organisers of the conference for the great job you did. The event ran very smoothly, the content was superb and the social was really memorable. I’ll be watching twitter for the announcement of #phpbnl11, as this event was so popular I don’t want to miss the next!

To all my newly made friends, I look forward to seeing you in London for PHPUK.

Content Links:

Dependancy Inject Slides:

http://www.slideshare.net/fabpot/dependency-injection-with-php-53

SOAP Slides:

http://www.slideshare.net/Wombert/the-state-of-soap-in-php-3029206

Cloud Slides

http://www.slideshare.net/ijansch/php-and-the-cloud (couldn’t find the most recent version of these slides?)

PHP Benelux Day +1 from Ben Waine on Vimeo.

Ben

PHP Benelux Day -1 from Ben Waine on Vimeo.

Ben

After working with PHP for nearly two years I’m excited to be have been given the oportunity to gain the coveted title Zend Certified Engineer.

After doing some of the practise exams (buy them here), I’m starting to feel more confident. They provide a good way to structure your learning and highlight areas of PHP you may not use on a day to day basis.

They take the form of a 70 question multiple choice style test paper. Ninety minuets are allotted to complete the test. I find that one hour is sufficient, with the additional time required to check through the more tricky questions. Speaking of tricky questions,  the exam is littered with what could be considered ‘trick questions’. At first glance the answer seems evident however on closer examination a nuance of the language is used to produce the correct answer.

This inevitably produces a feeling of ‘exam paranoia’, I end up triple checking even the apparently easy questions.

I think the three day Zend Certification Course will help exorcise this feeling to some extent as the common ”gotchas’ that appear in the paper will be covered.

Wish me luck!

Ben