Before PHP  went OO and autoloading existed, users had little choice but to place require_once statements throughout their code to satisfy the application dependencies.  At the start of a project this was fine as the dependencies were thoughtfully mapped out and the require_once statements strategically placed.  However, as time goes on and code goes through maintenance the require_once creep starts to set in.

What do I mean by require_once creep?  I simply mean that there are require_once statements including code that doesn't need to be included.  This caused a couple of problems:

1. More code for the PHP parser to parse and thus a slower application
2. Confusing code dependencies

Now, admittedly problem 2 is not the major issue problem 1 is.  However, nothing is more frustrating than removing a innocuous require_once from a file only to have some other random file break because it was including that file and depending on that require_once.  There is an entire PHP extension dedicated to helping people solve this very problem: inclued.  I still remember Mozilla's conference talk about refactoring TikiWiki to not simply include every nearly every single library file on every single page.

To fix this problem, autoloading was introduced.  This allowed people to stop using require_once and spawned a method of pseudo-namespacing files.  One of the more popular methods of psuedo-namespacing was the PEAR standard.  This standard said to name the class based on the directory location of the class.  So if I have class in herman/awesome/Solution.php I would name the class Herman_Awesome_Solution.  This obviously gave rise to some pretty long class names, but people generally loved it as it saved them from require_once creep.

Let's fast forward to PHP 5.3.  The "use" keyword is introduced to let users alias long namespaces to a shorter name.  So I can reference the namespace \this\is\a\really\long\namespace as longns.  This is great, now I can reference a really long namespace with a single word.  All I have to do is remember to alias it.  And the aliases are descending, so if I alias a class that alias two other classes, I can use those additional aliases free of charge.

But wait, doesn't it seem like we just went full circle with naming conventions?  We started with simple class names with require_once creep, graduated to autoloading and using super long class names and are now back using simple class names with use creep.  The use creep doesn't have the performance halting side effects of require_once, but it sure seems like it can cause quite a dependency maintenance nightmare.  It may be no problem for you, but what about the guy coding next to you who really doesn't care?

I think I will stick to using the fully qualified namespace (FQN) of a class.  It will take a few more keystrokes, but it keep my dependencies cleaner.

$baz = new \foo\bar\Baz;

The spl_autoload() function gets passed the fully qualified namespace as well as the class name. This is very similar to the PEAR class naming convention of using underscore characters (_) to denote the path to a class.

Consider the following:

The spl_autoload() funtion is passed the string 'foo\Bar'. The extensions registered by spl_autoload_extensions() are then used in conjunction with include paths to look for a valid file. The spl_autoload_extensions() function has the extensions .inc and .php registered by default. The default include_path is the current directory, so let's assume the current directory is D:\herman\php.

List of attempts by spl_autoload() to load the class from the above example:

• D:\herman\php\foo\Bar.inc
• D:\herman\php\foo\Bar.php

This means that you can map each namespace to a directory in your application. Consider the following directory layout.

blog\
models\
Author.php
controllers\
PostController.php

The namespace for the Author class in the Author.php file should be 'blog\models'. The namespace for the PostController class in the PostController.php file should be 'blog\controllers'. Using this namespacing strategy along with a proper include path allows php to autoload your classes out of the box.

Remember, this only works with PHP on Windows.  I have a pending patch to make spl_autoload() work with namespacing by default on Linux.