When writing the handler system for Mai Ocean I had to find a way to access a static class that had a variable name. Accidentally I found the new class_alias() function on php.net. This function gives you the ability to easily create a alias for any class. Usage is simple:

class_alias('New', 'Original');

The function is available in version 5.3 and above and works with namespaces. In Mai Ocean I just use the following:

$handler = 'MaiOcean\UserHandler\\' . $this->config()->handlers->name;
 
class_alias($handler, 'MaiOcean\UserHandler\Handler');

Now I can just use my new name instead of a variable! How great is that?

DEC Alpha AXP 21064 microprocessor

PHP can do only one thing at a time. Usually (for websites) this isn’t a big problem because you only have to process a request. On the other hand, if you are doing something more time-consuming PHP could be to slow.

An example is my chat bot server (Mai Ocean). For each conversation I have to make a connection with a server, so for each conversation I have a socket that I have to listen and write to. So if 10 people are talking to my bot I have at least 11 socket connections (10 conversations + main server), you could imagine that this would be way to much for just one script. So how can we solve this?

With multiprocessing! Multiprocessing is a method to run multiple processes and give each of them a task to do. In the following weeks I am going to write about different ways to implement multiprocessing:

1. Part 1: Quick & Dirty (using exec())
2. Part 2: Parent & Childs (using PCNTL)
3. Part 3: Communication (using proc_open())

Today I will cover the first part and will talk about the easiest method using exec(). This method is very simple but you cannot do much with it. Anyway, lets begin: First of all we should create a parent process. No matter what method you use you always have to create a parent. The parent process creates all the child processes and can differ from its children but can also be the same.

Today our child processes differs from the parent because we have to add some code to our parent to start up its children. A simple diagram of our program could look like this:

As you see we have one parent process and three children. For this article I will use only one child script to make it easier. So before we look at creating child processes we first have to write a child script. Your child script can do and contain anything you want but it must be possible to run it from the command line.

For the rest of the article I will be using the following child script and name it child.php:

< ?php
date_default_timezone_set('Europe/Amsterdam');
sleep(2);
echo date("H:i:s");
?>

The child will first wait for two seconds and then output the current time. You should note that this child exits by itself, that is something to remember for next time. Now we have a child we can create the parent script. In this example the parent should only start its children and then exit:

< ?php
for($i = 0; $i < 5; $i++)
{
	echo "Starting child $i\n";
	echo exec("php child.php") . "\n";
}

Now save the code (for example as parent.php) and run it from the command line. If everything works you should see something like the following:

$ php test.php
Starting child 0
20:34:00
Starting child 1
20:34:02
Starting child 2
20:34:04
Starting child 3
20:34:06
Starting child 4
20:34:08

Now how does this work? The parent uses the exec() function to start up a child. As a parameter we used the command php and the name of our child child.php. exec() will run the command and return the last line from the result. In our example this is the current time. Of course you could also add some arguments to the command to interact with the child script.

If you look closely you see that there is an 2 seconds interval between each start of a child. This is caused by the sleep function of each child. In other words our parent script has to wait for the child to complete before it can continue. When you need multiprocessing you do not want this because you do not have any profit from it. So how can we fix this? As stated on php.net:

If a program is started with this function, in order for it to continue running in the background, the output of the program must be redirected to a file or another output stream. Failing to do so will cause PHP to hang until the execution of the program ends.

Therefore if we want to let our children run in the background we have to direct the output, this can easily be done by changing the command:

exec("php child.php > /dev/null &");

The code above will send all output to /dev/null and there it will disappear. When you use this method the script runs in the background and will not let the parent wait. The parent will start 5 children without waiting for the first to finish.

NOTE: The method above does not work on Windows! It will only work on Unix systems. If you want to use it on Windows you should use another method. A possible solution is replacing the exec() command with pclose(popen("start /B ". $cmd, "r")); but I did not test it myself.

What do we have so far? We have a parent script that starts up 5 children that run in the background. The children in this case are useless because they output to /dev/null and you will never see that. Nevertheless you should be able to create more useful child scripts for yourself. For example: each script could backup a different database or file.

With the above you should be able to create programs that implement a form of simplistic multiprocessing. To make it all a bit better (and more difficult) we should let the parent and children communicate with each other. There is only one problem: the method we used here is not really useful when we need communication. This is because we cannot interact with the scripts directly, to do this we need another method (which I am going to discuss in the following articles).

If you still want to use this method (because you have not yet read my following article or I didn't finish it yet ) you can use files. For example (from a previous version of my bot server) a conversation script checked every 2 seconds if there was a 'server-stop' file present in the temp directory of my application. When the file was present the child would close the socket and exit by itself. The reason why I am not going to explain this is because it is ugly and I want to forget that I every used it .

So in conclusion, we have looked at exec() which is a function to execute commands and used it to start child processes. This way is useful if you need it fast and do not have the time to create a better method. In the next part I am going to explain a more advanced method of creating parent and child processes.

See you next time!

Hell or Heaven?

If you have used PHP before you should already now the answer to this question. It is definitely yes. I have never heard someone saying that the documentation was bad or somehow not good enough. Even people who hate PHP can’t disprove that (of course they could try).

Anyway, why is it so good? I think it’s most important aspect is it’s completeness. If I’m writing C++ and I want to know something about a function or the language in general I go to Google. When I need to know something about PHP I go to (you should know this) php.net. I do this for one simple reason: the PHP documentation contains all the information I need. Even when that is not enough, each page has a lot of user contributed notes to help you even further. I only need Google when I’m searching for a tutorial or more in-depth information about a topic.

PHP Documentation

The PHP documentation itself contains a full list of functions, information about the language itself, security information, etcetera, etcetera.. So in a few words: it contains a lot!

In comparison to a few other languages: C++ has cplusplus.com and Sun gives information about Java. More than once I concluded that these documentations where not the answer to my problem and I had to search on the web. Of course this doesn’t say that these languages are bad. It just says that developing an application with a language that doesn’t have a good documentation could take much longer.

You should know that I am not saying that PHP is good because it has the best documentation of the world, I am just saying that the good documentation makes PHP a better language to use. I do not know if PHP has the best documentation but it is definitely one of the best. (Another language with a good documentation is Python.) The documentation is something what some other languages lack and maybe should get more attention.

(Combining the previous article and this one we could say the score is 1 -1. PHP may have lost the previous one but the documentation surely gets it back into the race!)

The development in the rankings can be found in the graph below:

Long term trends for the top 10 programming languages

The total ranking list can be seen on the TIOBE website.

Sunflower seedlings

After the start of your (PHP) application it will grow. You will include more and more files, execute more functions and handle more data. When you are finished processing, all memory will be released and your app will ‘die’. Summarized you could represent your application as something simple like a plant!

The first part of “it’s life” is germination, your application has to start and set up everything he needs. In more technical terms you can call this term the bootstrap. If you use a framework such as Zend Framework you’ve probably already heard from it. Using a .htacess file you direct all traffic to your bootstrap that then will startup the main application. For a person like I (who creates PHP CLI apps) the bootstrap is a way of setting important environment variables. So what should a bootstrap do? In my view the most important tasks are:

1. Setting application environment
2. Configuring the PHP environment
3. Configuring autoloading
4. Loading configurations
5. Starting the main application

I doesn’t seem like much but if you use them properly a bootstrap can be really helpfull. Moreover, if you (like me) only program using objects (OOP) you need a file that starts your main class so you need a bootstrap anyway.

Now I want to further explain these 5 components of the bootstrap using a live example: the bootstrap of Mai Ocean. I will try to keep it as general as possible so I won’t use a framework. Of course I only give my view, the best bootstrap is the one that fits you and your app so after reading this post go create your own and share it if you like!

1. Setting application environment

let’s start with the first part: the application environment. For all my applications I start with some ‘application constants‘. I use these to define global information about the application. For example, Mai Ocean has the following constants:

define('APP_NAME',		'Mai Ocean');
define('APP_VERSION',		'0.1.0trunk');
define('APP_STAGE',		'development');

Because they all start with the prefix “APP” I can easily identify and use them throughout the application. The first two I only use for informational purposses and are not needed for the application. For example: bots created with Mai Ocean show the name and the version of the application in their private message. The third constant (APP_STAGE) is the most important and is actually used. I split config files in multiple sections and this constant defines what section should be loaded (in this case the development section). You may think: “This is pretty simple..” and you are absolutely right but constants like these can be really useful.

Because I use autoloading I have to define paths to my models, controllers and other classes to make it work. These paths are part of my application so I define them (just like the application constants) with constants. Due to this I can always use a constant if I want to use a path, then when I want to move something I only have to change the constant. For Mai Ocean I use the following:

define('PATH_ROOT',		__DIR__);
define('PATH_LIBRARY',		__DIR__.'/library');
define('PATH_EZCOMPONENTS',	__DIR__.'/library/eZComponents');
define('PATH_APPLICATION',	__DIR__.'/application');
define('PATH_CONTROLLERS',	__DIR__.'/application/controllers');
define('PATH_MODELS',		__DIR__.'/application/models');
define('PATH_HANDLERS',		__DIR__.'/application/handlers');

After this I can set my include path. As you might already know, the order of your include path is important because they are searched. PHP will search them in the order you’ve set them so set the most important directories first. I usually start with my application and models dir because it contains the most files I use:

set_include_path(
	PATH_APPLICATION 	. PATH_SEPARATOR .
	PATH_MODELS		. PATH_SEPARATOR .
	PATH_LIBRARY		. PATH_SEPARATOR .
	PATH_EZCOMPONENTS	. PATH_SEPARATOR .
	PATH_HANDLERS		. PATH_SEPARATOR .	
	get_include_path()
);

2. Tweaking the PHP environment

The first part was pretty simple so lets continue. PHP has a large config file (php.ini) and especially when you write applications that will be used on multiple installations you should not trust them. If you rely on some config values you should set them yourself. The best place for that is (you could have guessed it) your bootstrap!

Probably the most important settings you should configure are the error settings. Of course you can change these with error_reporting() but I like to use ini_set() instead. When developing you want to show errors on screen, this is easier than reading a log when something goes wrong. Nevertheless, when you are ready for production you do not want to show errors any more. Instead of displaying them on screen you can easily save them to a log file. You could also create a custom error handler that would send an email to you or something like that. Anyway to set the error settings you could use the following:

ini_set('display_errors', 	0); //Do not display errors on screen
ini_set('error_reporting', 	E_ALL | E_NOTICE | E_STRICT); //Show ALL errors
ini_set('log_errors', 		1); //Log errors
ini_set('error_log', 		PATH_ROOT . '/log/error.log'); //Path of the error log

Some other settings I use often are memory_limit (to handle a lot of data) and max_execution_time (to enable scripts that run forever). All settings you can set can be found at the PHP Manual: http://php.net/manual/en/ini.list.php.

Besides errors I also always configure assertions are handled. I use them a lot and configuring them makes them even more useful. I’d already written down some of the possible configuration in my post about assertions (Assertions, protection against yourself) but wrote down my full configuration list below:

assert_options(ASSERT_ACTIVE, 		1); //Enable assertions
assert_options(ASSERT_BAIL,			1); //Terminate execution on failed assertions
assert_options(ASSERT_WARNING,		1); //Issue a PHP warning for each failed assertion
assert_options(ASSERT_QUIET_EVAL,	0); //Do not disable error_reporting during assertion expression evaluation
assert_options(ASSERT_CALLBACK,		'someFunction'); //Some function to handle assertions (don't have one yet)

This configuration I use when developing because I want to see when an assertion fails. On production I would disable warnings and let my callback handle the error.

Now there is only one thing left we need to configure. When you use date/time functions you may have already have seen this:

Note: Since PHP 5.1.0 (when the date/time functions were rewritten), every call to a date/time function will generate a E_NOTICE if the timezone isn’t valid, and/or a E_WARNING message if using the system settings or the TZ environment variable.

So we have to set a valid timezone, this is really easy. Just add the following to your bootstrap:

date_default_timezone_set('Europe/Amsterdam');

3. Configuring autoloading

I can be short at this: autoloading is great! I am not going to explain how autoloading works because it is pretty straightforward. I use Zend_Loader_Autoloader as a base who uses the autoloader of eZ Components and also my own autoloading algorithm. In my bootstrap I only have to do the following:

//Get the Mai Ocean autoloader
require_once('Autoloader.php');
//Create a new autoloader for this application
$autoloader = new MaiOcean\Autoloader;

4. Loading configurations

My controllers, models and other objects use configurations who I store in ini-files. These files are loaded and parsed in my bootstrap because I do not want to define them into my objects. Also, (unit) testing will be a lot easier if you can insert custom configurations.
My favourite method is creating a config creator object that combines multiple ini-files in one Zend_Config object.

//Create a config object to load all config files
$config = new MaiOcean\Models\Config;
 
$config->addModule('application/default');
$config->addModule('users/development');
 
$config = $config->createConfig();

In the example above I load 2 ini-files: the default configurations and the development user data. The last line will return a new Zend_Config object that contains all my configurations.

5. Starting the main application

You may have noticed but we have reached the last part: starting the main application. This is important but also the easiest part. If you use a framework you will probably dispatch a front controller. In my case (a CLI application) I just start up the main controller:

//Create and run the controller for the Mai Ocean application
$controller = new MaiOcean\Controller\MaiOcean($config);
 
$controller->run();

The end..?

We have reached the end of the bootstrap and of my article. I hope you’ve learnt something about my way of creating bootstraps. I’m very curious about your ideas so let me know! The full bootstrap of Mai Ocean can be found at launchpad.

1. Bootstraps (already working on this)
2. Compiling PHP (an idea by Jasper)
3. More “PHP, Hell or Heaven?”
4. Running multiple PHP scripts at once (and let them communicate!)
5. eZ Components (especially the Console Tools)
6. Text analysis with PHP

(You may have noticed that I copied some from the Mai Ocean introduction post.)

When I was writing this I also came up with some questions: What do you think about these topics? Which do you prefer and do you have anything to add? Especially for the series “PHP, Hell or Heaven?” I would like to know what you like about PHP and (maybe even more) what you hate. Thus for all people out there that hate (or dislike) PHP: This is your time to speak!

Hell or Heaven?

In PHP there are multiple data types but the main difference between other languages (especially more low level languages such as C++) is that you can assign any value to any variable. This is also called type juggling. Therefore in PHP the type of an variable is defined by its content and not by the developer or by the way it’s been set-up. For example, you could do the following in PHP:

$var = 1;
$var = 'a';
$var = 3.0;

You should note that the type changes in the example above. So the type will change from an integer to a string and finally to a float. In other languages you have to define a type which can’t and will not change. Now to get back to the topic (is PHP hell or heaven?) we have to answer a very important question: do we like this?

For beginners I think it’s great. You can start with learning basic skills such as control structures and don’t have to worry about the types of variables. On the other hand more restrictive rules will (possibly) make you a better programmer. When you can’t juggle with types, you won’t. Anyway when you are getting better at PHP you probably think about what you assign to variables so it becomes a bit less important. For instance I use phpDoc for every large project I work on so I define types for variables like this:

/**
 * Will output name and value.
 * @param string $name
 * @param int $value
 * @return void
 */
function test($name, $value)
{
	echo $name . ': ' . $value;
}

As you see I wrote the variable types in my docblock. Nevertheless nothing is stopping me from using other types. I could just run test(23, 1). A possible solution to this is using assertions (see also Assertions, protection against yourself). So, if we combine phpDoc with assertions we would get:

/**
 * Will output name and value.
 * @param string $name
 * @param int $value
 * @return void
 */
function test($name, $value)
{
	assert('is_string($name) && is_int($value)');
 
	echo $name . ': ' . $value;
}

Above we have a function that only accepts variables of a defined type. That is good, if we accidentally used wrong values we will get an error. That is also very useful for people who don’t know how your code works but (have to) use it. Then again if we look at another language (in this example C++) we see how it can be done much and much better (and also easier):

void test(string name, int value)
{
	cout < < name << ": " << value;
}

Combining all these facts I think PHP fails in this case. I like being strict and better type handling would improve that. We will also be relieved from writing all kinds of value checks which are boring..

Is there a solution? Yes and no. Since PHP5 you can use type hinting for arrays and objects. In the header of the function you can define for only these two types what the value of the parameter must be:

function example1(array $param1) { }
function example2(Class_Of_Some_Kind $param1) { }

The above is a good start (I use it very often) but you cannot yet use it for integers, floats and other types. For those types we have to do something else. I just recently found an experimental extension that gives more opportunities for better type handling: SPL Type Handling. This extension offers five objects you can use for type handling:

$integer = new SplInt(12);
$float = new SplFloat(0.2);
$boolean = new SplBool(true);
$string = new SplString('hello');

The fifth object is SplEnum and is abstract. You can only use this object if you extend it. For each of these objects applies: if you try to assign an invalid value an UnexpectedValueException will be thrown. I have not yet used these new objects in one of my projects but I am definitely going to check them out. I don't think they are useful for all variables but they could be a nice addition to models. You can find more information about the usage of these objects on the documentation page:

http://php.net/manual/en/book.spl-types.php

As I said, I haven't yet used them so I can't say anything about performance. If they are slow or consume to much memory they are useless. When I'll know more I will post my findings here. For now I think I've told you enough about type handling in PHP. It is time for you to decide! What do you think? Do you like the way types are handled in PHP? Is type juggling useful? Or is it like hell? What do you think about this new extension? Let me know

Unit testing with PHPUnit

In computer programming, unit testing is a software verification and validation method in which a programmer tests if individual units of source code are fit for use.

However, I haven’t done it a lot. Why? Honestly I do not know. I tested PHPUnit last year but I never used it again. Anyway this is the time to change that! I’ve found a interesting series written by Giorgio Sironi titled: Practical testing in PHP.

I am definitely going to check it out. The articles can be found here:

Edit (26-11-2009):

I was reading some of the blogs that I follow and I also found a series about unit testing written by Jani Hartikainen. I have been following Jani for a while and he is a great inspiration so I recommend you to read these articles too. Anyway here they are:

1. Unit testing introduction
2. Writing and running tests
3. Writing tests for exsisting code
4. Mock Objects and testing code which uses the database
5. Test-driven development

Edit (03-12-2009:
Giorgio Sironi (the author of the first series) released a e-book about unit testing. It contains his articles about unit testing and some new content:

http://giorgiosironi.blogspot.com/2009/12/practical-php-testing-is-here.html

1
2
3
4

function calculate($number1, $number2)
{
    return $number1 + $number2;
}

Of course this example is very simple, I also hope you never create a function for such a basic calculation. Nevertheless it will be useful as an example. If we put our function to the test we can see some problems:

5
6
7
8

echo calculate(1, 2) . "\n";
echo calculate(1, 'a') . "\n";
echo calculate('a', 'b') . "\n";
echo calculate(new ArrayObject, new ArrayObject) . "\n";

Normally on a live server (with error reporting off) the output will be: 3, 1, 0 and 2. The first calculation is valid and just prints what we expected. The other calculations contain other characters than numbers so the outcome is a bit odd. Only the last calculation (when showing notices) will trigger a notice telling you that ArrayObject cannot be converted to a int. Of course we shouldn’t use non-numeric values with this function but during development we could made this kind of mistake.

So how do we fix this? We need a way to tell us that we did something wrong. The most common way is to add some more code that checks our preconditions ($number1 and $number2 must be numeric). You could do this like this:

1
2
3
4
5
6
7
8
9

function calculate($number1, $number2)
{
    if(!is_numeric($number1) || !is_numeric($number2))
    {
        echo '$number1 and $number2 must be numeric!';
        return 0;
    }
    return $number1 + $number2;
}

This function will show a nice error message when you used wrong values. Using this method will make debugging easier because your code will tell you what went wrong. However why should we add five extra lines to our (one-line!) function? If we just remember the usage of this function we could also make sure we never use the wrong values as parameters. But then, if we forgot the usage we could spend our valuable developing time debugging why calculate(’a', ‘b’); went wrong.

So we have to find a good balance between less code (read less writing) and good usability. And this is the point assertions are useful. Assertions are pretty easy to use and you basically only have to know one function: assert(mixed $assertion);. As an parameter you use the assertion (or condition) you want to check. An example:

$number = 'abc';
assert('is_numeric($number)');

When executing this code (through command line) we see the following result:

> php -r "$number = 'abc'; assert('is_numeric($number)');"
 
Warning: assert(): Assertion "is_numeric($number)" failed in Command line code on line 1

Our assertion failed! And that is precisely what we wanted. Using this method we can easily check our preconditions on functions. The assertion inside the function will be checked and it will show an error when it returns false. So to improve our calculate() function we could do this:

1
2
3
4
5
6

function calculate($number1, $number2)
{
    assert('is_numeric($number1) || is_numeric($number2)');
 
    return $number1 + $number2;
}

Now we rewrote our check method in just one line. But there is more! We can also tweak the working of the assert function through assert_options(). There are five options you can change with this function but the most useful option (in my opinion) is ASSERT_BAIL. When enabled this option will make assertions terminate your application when failed. I find this very useful for testing. To enable ASSERT_BAIL just add the following line before your assertions:

assert_options(ASSERT_BAIL, true);

The other options and what they do can be found at the PHP documentation page.

So far we have seen that assertions can be really useful yet should assertions be used for every check? In my opinion you should only use assertions to check parameters that are not user dependent and that can only be invalid during development. Assertions are a way to help you develop and debug your application, not short cuts for validating user input. Quoting from PHP.net:

“Assertions should be used as a debugging feature only. You may use them for sanity-checks that test for conditions that should always be TRUE and that indicate some programming errors if not or to check for the presence of certain features like extension functions or certain system limits and features.

Assertions should not be used for normal runtime operations like input parameter checks. As a rule of thumb your code should always be able to work correctly if assertion checking is not activated.”

Hopefully you now understand the basic idea of assertions. They are great development tools and can even be disabled for production.

Mai Ocean Logo

Besides studying and living I like to work on my Open Source project Mai. Mai is a project that consists of several sub projects and one in particular, Mai Ocean, I want to discuss here. It is currently my focus of development because it is an vital part of the Mai Project.

So what is Mai Ocean exactly? In a few words you could say that it is a bot server written in PHP. Of course this doesn’t say much so let me explain further. Mai Ocean can (or will be able to) manage an instant messenger bot that can interact using the MSN, Jabber and IRC protocol. Currently only the first is being developed.

A few weeks ago I finished the first draft version and now I decided to rewrite the code and eventually release it through Launchpad. In this process I will touch many PHP and coding related subjects and for that a great inspiration to write blog posts. Here is a small list that I want to discuss:

1. Creating a good bootstrap and base structure for the application
2. Namespaces in use
3. eZ Components (especially the Console Tools)
4. Running multiple PHP scripts at once (and let them communicate!)
5. Designing a handler system

Of course I will keep the topics as general as possible. I don’t except everyone to join my project and start helping me. (If you want, you’re welcome ) If you want to check out the progress or get some more info you can go to the Mai Ocean project page.