The Awesomeness of PHP __autoload

Many of you have probably written or at least tried to write a PHP framework at some point during your career. The best way to write a frameworks, in my very humble opinion, is to use object oriented programming (OOP) and a sort of model/view/controller (MVC) architecture. In most cases this means that by the end of writing a sort of usable system you will have a large amount of files filled with different bits of code.

In the bad old days before PHP 5 you would have an index.php file and that looked something like this:

<?php
/**
 * Index file of Xframework.
 */

// Include all sorts of useful stuff...
include_once '/category/uncategorized/bootstrap.html';
include_once '/app/model/x.class.html';
include_once '/app/model/theme.class.html';
include_once '/app/controller/user.class.html';
include_once '/app/view/index.html';

// Now we can finally do something.
$x = new x();
$x->run();

Wouldn’t it be really nice if we could just write the code without having to worry about including millions of files everywhere, which can become a pain in terms of maintainability.

Enter __autoload() in PHP5. YAY! All our troubles magically disappear. Well not really, but your life is made slightly easier. So instead of the above, you now have:

<?php
/**
 * Improved index file of Xframework.
 */

// Our pretty __autoload() function.
function __autoload($classname) {
  include_once '/app/classes/'. $classname .'/category/uncategorized/.html';
}

// Run the framework.
$x = new x_controller();
$x->run();

Using __autoload should theoretically also improve the speed at which your app loads because you only load the files that are needed at the time.

You could also do some really complex configurations like the below for example:

<?php
/**
 * A more complex __autoload example for Xframework.
 */

// Autoload some classes.
function __autoload($classname) {
  $class = explode('_'. $classname);

  $class_file = $class[0] .'/category/uncategorized/.html';
  $class_type = $class[1];

  // Include the class.
  include_once '/app/'. $class_type .'/index.html'. #class_file;
}

// Let's run the app.
$x = new x_controller();
$x->run();

In the example above the autoload function is checking the class name for a type. The type could be, for example, model, view, controller, elephant or whatever you wanted it to be. That type is the directory where the class is stored. In the example we called the x_controller class. So that class would be located at /app/controller/x.php, the same would be true if you wanted it to be x_model or x_view.

This most definitely makes my life easier when I write PHP applications. If you spend a lot of time writing PHP applications and don’t use a specific framework for the job I would suggest that you put together a rough toolkit for yourself using __autoload() as the heart.

When designing for the web, is the customer always right?

When I began thinking about this friction between clients and designers I tried to find a real life example to best describe how the relationship should work.

First I thought that it was rather like a person who wants to build a house. A person who wants to build a house looks for an architect, but they usually start out with a fairly good idea of what they want. They can show the architect rough sketches, magazine clippings and whatnot. So essentially the architect is just there to give advice, draw the plans and make sure that the house looks like the owners want it.

This works great except that a personal house only needs to fit the need of one person (maybe more if the client has a family but we will assume that they all were part of the planning). So for example if the client is short they may want to have kitchen cupboards that are quite low or floor level, this will be inconvenient for a taller person.

This scenario does not really fit the web because the web is not like a home, rather it is like a public building – a library or museum for example. The web cannot by its nature fit one person, neither can it fit everyone so a compromise needs to be arrived at. This compromise is, by using gathered knowledge, fit the largest group of people possible.

the web is not like a home, rather it is like a public building – a library or museum for example

With this in mind lets explore the process for designing a public building. A public building needs to be designed with the public in mind, this is the huge difference between designing a home. Yes the designs are begun in much the same way, a client with an idea finds a n architect. But in this case the client is usually a government or large company. They would probably start by getting a team of consultants together, these would be architects, designers and other people like that with experience in designing public buildings.

The client will then move to the background white the team puts together a design and then gets feedback from the people that are going to be affected by the building. Once all the required feedback has been gathered the team will then use it to make changes to their initial design. Once they are happy with what they have put together they will go back to their client, discuss it, maybe make one or two minor changes and then get on with the next stage.

The way a web design comes together follows the second scenario I proposed much closer than the first. Let me explain. The client starts out with an idea, they may go to a design company with some preconceived ideas but in most cases they just present their idea. The design company will then mull over the idea and try to build a design around it. This is done by using expertise from prior projects as well as doing usability studies and maybe a few other things as well. The usability testing involves the public in the design process by letting them show the design team how their design works in practice, the public can then also give their opinions. When all the tests and procedures have been completed the web design company will have a design that is both functional and one that works for the biggest possible amount of visitors.

Once the company is happy with what they have put together they will take it to their client and they will then make slight changes here and there. Once everyone is happy then they can procede to the next stage.

Conclusion

In conclusion I think that there are a lot of parallels that can be drawn from the second scenario. First, the client takes a less important role in the design because he trusts the team he has employed that they will give him the results he asked for. Second, the public is involved in the design process in a controlled way that allows them to influence the design but not derail the process with nonsense.

The biggest problem here is trust, clients need to trust that the team they have employed will do the job properly. What we do at Amoebasys is use Redmine (http://redmine.org), which is an online job tracking system, so that the client can see exactly what is going on. They can follow as each job task is signed off and this makes them happy.