Methods (not classes) can be defined as static (eg. not static class Oliver{} but rather static function talk()) in order to call them without going through an instantiated object. From my perspective, it makes code cleaner and less messy by wrapping related functions in a class wrapper instead of defining them globally. It should be noted though, that classes with static methods CAN be instantiated, and those methods can be called either statically (via the :: double colon notation, or via the -> right arrow notation on the instantiated object).

That takes us to abstract classes. Abstract classes CANNOT be instantiated. They can be the parent of a class which can be instantiated, but they themselves cannot be. So for example, if I have two types of users, RegularUser and AdminUser, I could create an abstract class User which defines method signatures (via the abstract keyword) like abstract function login($username,$password){} or I can define static functions which can be called (via the same rules as above). A new User object can never be created directly though.

So what does that mean in terms of real-world usage? Personally, if I don’t want a class every to be instantiated, such as a class that has utility functions or string manipulation functions, I will define it as abstract, and define all it’s methods to be static. If I have a parent object which should never be instantiated, I’ll do the same, but leave the method declarations to the child classes for the most part.

So then when do I use a normal class that happens to have static methods? I haven’t really. I’m sure there can be uses for it, but I’ve never found myself in a situation where I need to access an object’s method without the context of the object’s instantiation. Maybe it’ll come up one day, but as I’m moving closer and closer to a full mvc based coding life style, I have a feeling that I won’t find myself in that situation anytime soon.

Since my framework is MVC based, I ran into a problem whereby calling an action/method in a controller should only be fulfilled if the number of parameters passed in was valid. So for example, if I was dealing with a user’s model, and I wanted to return the email address for the user, I would normally access it via a url pattern such as: http://www.website.com/users/details/email/

On the server side, this would access the Users controller, the details method, and pass in a parameter with the value ‘email’. The method would then grab it from the db, and return it however it decided. The trick came in, however, as to validating the parameters that were passed to a controller’s action/method. So for example, http://www.website.com/users/details/email/oliver/ would pass the details method/action two parameters with values ‘email’, and ‘oliver’.

But my method/action only accepts one. So what should happen? Well ideally, a 404/error page should be pushed out, but how would PHP know that the parameter count doesn’t match? You have two options. One is very intrusive, and the other is best thing ever.

1) Intrusive: in every action, hard code something like:
if(func_num_args()>HARDCODED_NUMBER)
// redirect
This would mean every action/method would need to do this check to make sure the right number of param’s were sent in (this doesn’t even take into account the minimum number of req’d parameters; only the max allowed.

2) The best way ever: before making a call to controller’s action use the Reflection class.
This class allows you to check the parameter requirements of a call BEFORE you actually make it. So using php5’s Reflection class, you can check to see how many parameters are required at a minimum (excludes required praams’), how many are the max, and even more fun stuff. This allows you to centralize the error handling for controller calls to the dispatcher (my naming convention for the class/method that actually makes the calls to an action/method), keep your code very clean and clear.

I did some checking, and it seems using this class isn’t too expensive since this information is contained by php be default; it’s just that this extension contains the API for actually accessing it.

It’s a win-win situation as far as I’m concerned.

Basically, this framework has a bunch of settings/config files, and some of the files (ini format, using parse_ini_file) are seperated by the following keywords:
local,development,staging,production

Basically meaning, if I have a configuration setting that is supposed to mean something like ‘maxTimeout = 500′, I could, and in a real world application, would have that setting store different values based on which server the code base is being run on (eg. my local would be a lot higher, but the other ones like the production would be much lower for optimization purposes).

This lead me to write some nifty code that will parse all the ini files, and then when I want to retrieve something, it does a check for one of those 4 reserved words. So a real world example would be something like this:

An ini file is parsed and has the following format:

Array
(
[local] => Array
(
[name] => TEST
[cookies] => 1
)
[production] => Array
(
[name] => TEST
[cookies] => 1
)
)


When doing a call to the function and asking for the setting ‘name’, recursively as it moves it’s way down the settings array, it’ll look to see if it contains a keyword of local, production, etc., and if it does, automatically set the value to that array/value. This will be clearer once I OS the framework which won’t be for a while, but to understand it from a code perspective, check this out:


public static function getDetails() {
$details = self::$details;
foreach(func_get_args() as $argument) {
$details = $details[$argument];
if(array_key_exists(Request::getServerRole(),(array) $details))
$details = $details[Request::getServerRole()];
}
return $details;
}


This means that my server will automatically pull the right setting detail based on what server is doing the requesting. I just need to setup my ini files so that if a setting needs to be different based on which server is being loaded, it can be.

I’ve been looking at frameworks a lot lately. Mainly for an upcoming project, but also to getting a better understanding of MVC based development, as well as components/helpers for web develop

ment. That made be ask the question, what framework does php.net use for it’s documentation/downloads site?

I read somewhere that Rasmus Lerdorf, the guy who invented php, who went to University of Waterloo, by the way, felt particularly fond of Code Igniter. I’ve looked at it, and heard great things mainly due to it’s ease of use, but echoing Rasmus’ thoughts, if feels much more like a library than a framework, at least to me.

That’s not a bad thing; Rasmus’ meant that positively. I personally don’t think you should be relying on an open source distribution to do the thinking for you. I’ve run into many people who claim to know javascript, but what they really mean is, is that they know how to use a framework like MooTools, JQuery, or YUI. Knowing JavaScript takes much more time, and takes a higher discipline. It’s not for everyone, but it’s not different than someone knowing how to use Dreamweaver or Frontpage, and advertising that they know how to develop website. You don’t know how to develop website, you know how to use a program that writes the sites for you, much like if you’re using a framework, you know how to use an open source distribution to help you write a website.

I’ve been playing a lot with CakePHP lately, and that, in my mind, is a true framework. Everything is native to Cake. Their site is very intimidating, and their framework is VERY expansive, but it’s therefore very powerful. I’m not sure it’s exactly what I was looking for, but it’s given me invaluable insight into framework development for php.

This then leads me back to the question of what php.net uses. My guess is a custom framework; not symfony, or cake, or CI, or zend or any of those guys (probably because they came about way later than php.net), but I’d be interested to know what they do use, and if they’d open source it. For now, I’ll keep working on my own framework that is geared towards being lean, and requiring me to do a lot of the heavy lifting for maximum flexibility. Hopefully I’ll open source it someday, and it’ll be able to meet the needs of people like me for whom Cake was too much, and CI (Code Igniter) was too little.