Currently on PHP's internals...

June 10, 2011 at 12:12 PM - by Freek Lijten - 4 comments

Tags: PHP, Internals list

The first, and perhaps most major, item I want to discuss is an RFC for a release process. PHP isn't exactly known for its smooth release process. PHP 5.3 took some time (understament of the century), and PHP 5.4 isn't exactly out yet either. While it was first mentioned as early as 2008! On top of that several tries to get a alpha out for 5.4 have stranded in discussion over what should and what shouldn't be included. Check out this thread for instance.

So releasing isn't going smooth, thats exactly why a group of developers took the time and effort to write up their ideas for a release process. I personally think it would be great if some sort of process would be established. Right now attempts at getting an alpha out all smother in discussion over one or two single features. It is no problem that discussion on said features takes place, but it is a shame that it holds back other great features which are since long ready and implemented.

Some features

While the RFC hopefully leads to something great it is not a feature request and I spoke of those too. So lets have look at some of them. I chose two features which seem to have met general consensus on their usefulness so chances are, you will once see them in action in PHP 5.4, whenever it might be released :)

Traits

The first example I'd like to share is a concept called traits. By now, PHP has a decent object oriented model but it lacks a feature. PHP only knows single inheritance making it impossible to create a class inheriting from more than one class.

I'll give an example where multiple inheritance was necessary for us. At Procurios we have a partial output cache called the fragment cache. This concept consists of a class that needs to be extended. There are however situations where a class that needs to be cached already extends from another class. For this situation an interface was created, defining several methods that needed to be implemented. The list of methods however grew and grew, and the interface itself was implemented at several places, in other words we were duplicating code.

We're now working around this problem by instantiating the fragment cache object inside the classes which couldn't extend but needed the cache functionality, but it is far from ideal. Below there is an example of how we could have used traits to solve this problem far more elegantly.

trait Fragment
{
    public function setFragmentInfo($fragmentInfo) { ... }
    public function setFragmentParameters($fragmentParameters) { ... }
    //etc...
}

//kiwi is a class which provides functionality to what are essentially smart dataobjects
class Article extends Kiwi
{
    use Fragment;

    public function getContent() { ... }
    public function moveTo($nodeId) { ... }
    //etc...
}

$Article = new Article($articleId);
$Article->setFragmentInfo(array( ... ));

This method is very much preferable to our current situation. The keyword use and the name Fragment after it ensure that the Article class could use all public functions of the trait as if it were its own. With traits the functionality needs to be implemented only once, and every random other class in our framework can use it without modifying the classes they extend from.

Array dereferencing

Another feature which is commited to TRUNK is array dereferencing. This functionality is best demonstrated with another code example (taken from the RFC):

function fruit() 
{
  return array('a' => 'apple', 'b' => 'banana');
}

//what you would normally do
$fruits = fruit();
echo $fruit['a'];

//what array dereferencing enables
echo fruit()['a'];

Simple right? In short array dereferencing enables you to treat the function result for what it is, an array :)

A newer feature

The two former examples are both features which are already committed to TRUNK, I would also like to give a recent example. This example concerns a concept introduced on June the 5th, introducing an array as callable. This is a vague description, I hope to clarify it a bit below. First an example with a string:

function bar($baz) 
{
    echo $baz;
}

$f = 'bar';
$f('baz'); //echo's the string "baz"

The code above is already possible in PHP, the callable array introduces the possibilities below

class Foo 
{
    public function bar($baz) 
    {
        echo $baz;
    }
}

$f = array('Foo','bar');
$f('baz'); //echo's the string "baz"

//also works
$Foo = new Foo();
$f = array($Foo, 'bar')
$f('baz');

Goodbye call_user_func?

A hot debate

Of course not all features meet a consensus. There is a reason the release process would come in handy remember? One of those features currently responsible for delaying a new attempt at 5.4 because of its hotly debated nature is the short array syntax. It is an RFC proposing a javascript alike method for creating arrays:

$a = [0, 1, 1, 2, 3, 5, 8];

$a = [0 => '0', 1 => '1', 1 => '1', 2 => '2', 3 => '3', 5 => '5', 8 => '8'];

$a = [0 : '0', 1 : '1', 1 : '1', 2 : '2',3 : '3', 5 : '5', 8: '8'];

What is the debate about you ask? Two things, firstly if it is useful at all, secondly about the way it should be implemented: should the notation use colons or => as seperator. Something which looks as minor as this can result in hundreds of messages and can postpone an entire release. Once again, the discussion is great, no feature should make the language without proper discussion and thinking (especially this one), but is is such a shame other features are stalled by this as well. I've said it once, I'll say it again: release process :)

Final message

So we've seen some features under discussion or even implemented in the current TRUNK. I hope this article gives an idea of the topics discussed on internals and that it inspires you to follow the list (more) actively. What is discussed there is the future of our language, if you want to see it enfold, the list is the place to be.

[edit]

I wrote this post just before the heavy discussion on the atmosphere on the list broke loose. See Stefan's blog for some more info. I do agree with most of the stuff he says, but I also remain confident that, all emotion and bad behaviour stripped out, the list remains an interesting place to check on the latest developements.

[edit2]

There actually is a very first tag for an alpha of php 5.4!