This is a retrospective of the year that has just ended.

In case anybody is still wandering, no, PHP 6 didn’t come out and it will probably not come out any time soon.

Why is it relevant? Since I started this blog, at the end of each year I had a post related to PHP 6 and the fact that it wasn’t released. In 2008 it was a popular question, but nobody is wondering  about that anymore, and so I will close this subject now. Let’s return to the year that has just ended.

Close to the middle of the year, the version PHP 5.5 was released, bringing features like: finally , generators and many other enhancements.

Like in 5.4, these are not defining features for the language. In this new version, there are functionalities that can be easily replaced, but if present, they are welcome.

Even though PHP is proving very dynamic lately, I think this year the main keywords were HTML5 and JavaScript.

HTML5 is seeing a lot of improvements and older components begin to have more momentum. The companies are beginning to invest in games that work in the browser using WebGL. Even older games are getting ported to the platform, using technologies like asm.js.

And, because I’ve brought games into the subject, it seems very interesting to me how only 5-7 years ago the games built with JavaScript were relatively simplistic, and now they can be compared with the ones from PCs and consoles.

I think the web revolution, which many were expecting, is taking shape. Finally the Web is a platform in the true meaning and JavaScript a language truly appreciated.

The success is due to all sides, it is not only about ECMA or only about browser manufactures, now it is truly dynamic. The Web revolution is in full blow!

When it comes to backend, the spotlight was on Node.js. It is becoming an important player on the market. New frameworks have appeared  and it isn’t a platform mainly used by hackers eager to explore new technologies anymore, but also by large companies, like PayPal, LinkedIn and Yahoo, adding a vote of confidence to it. I think Node.js is finding its place and a niche in the market, and, as a JavaScript fan, I can only be happy.

An advantage of Node.js is that you don’t have to take into consideration different JavaScript versions, like in the browser. It allows the use of the latest features from ECMA freely, an environment where you can develop JavaScript with not headaches.

Technically speaking, it was a very interesting year for web development.

Finally, I want to wish you all an extraordinary 2014!

The newest PHP version is almost ready. At the time I’m writing this blog PHP 5.5 is in RC 1.

As I was saying in my last blog, the feature list is available at: http://www.php.net/manual/en/migration55.new-features.php

The second feature, in terms of popularity, is “finally“: http://www.php.net/manual/en/language.exceptions.php

What’s the deal with “finally“?

It looks a little confusing, is looks like a block that’s getting executed after the “try/catch” finishes. But what is so new about it?

Let’s take a try/catch block:

PHP 5.x < 5.5:

 1// open resouce
 2$resource = new Resouce();
 3try {
 4   // do stuff with the resouce
 5   $resouce->doStuff();
 6} catch (Exception $e) {
 7   // log exception
 8   syslog(LOG_ERR, $e->getMessage());
 9}
10// release resouce
11unset($resouce);

PHP 5.5

 1// open resouce
 2$resource = new Resouce();
 3try {
 4   // do stuff with the resouce
 5   $resouce->doStuff();
 6} catch (Exception $e) {
 7   // log exception
 8   syslog(LOG_ERR, $e->getMessage());
 9} finally {
10   // release resouce
11   unset($resouce);
12}

Up to this point there isn’t any reason for a new block. The exception was catched, it was logged and continues.

But let’s say there is a resource and we need to close it, and after that we need to throw an exception. One way this can be achieved is to release the resource in catch.

But there is still the “successful” case, and we need to release it in that case also.

 1// open resouce
 2$resource = new Resouce();
 3try {
 4   // do stuff with the resouce
 5   $resouce->doStuff();
 6} catch (Exception $e) {
 7   // release resouce
 8   unset($resource);
 9   // perpetuate exception
10   throw $e;
11}

Let’s complicate stuff even more, let’s say there are n exception types. It will result in n catch conditions, plus the successful case, and in all of these cases we need to free the resource. Not very efficient…

Another way is to store the exception in a variable and, after the resource is released, to throw the exception, if that is the case.

 1// variable to store the exception
 2$exception = false;
 3
 4// open resouce
 5$resource = new Resouce();
 6try {
 7   // do stuff with the resouce
 8   $resouce->doStuff();
 9} catch (Exception $e) {
10   $exception = $e;
11}
12
13// release resouce
14unset($resource);
15
16if($exception) {
17   throw $exception;
18}

This is one way it is done right now. It’s working but it’s not clear that we are only trying to release the resource and continue our lives in peace.

The PHP 5.5 way

In the php.net manual:

In PHP 5.5 and later, a finally block may also be specified after the catch blocks. Code within the finally block will always be executed after the tryand catch blocks, regardless of whether an exception has been thrown, and before normal execution resumes.

Each time the block is executed, regardless if it was successful or not, finally will get executed. So, for the next example:

1try {
2    echo 'Do stuff' . PHP_EOL;
3    throw new Exception('testing');
4} finally {
5    echo 'inside finally' . PHP_EOL;
6}

The output will be:

1Do stuff
2inside finally
3
4Fatal error: Uncaught exception 'Exception' with message 'testing' in...

If we want to also catch the exception:

1try {
2    echo 'Do stuff' . PHP_EOL;
3    throw new Exception('testing');
4} catch (Exception $e) {
5    echo 'do something with the exception' . PHP_EOL;
6} finally {
7    echo 'inside finally' . PHP_EOL;
8}

The output will be:

1Do stuff
2do something with the exception
3inside finally

And even if we take the particular case when we catch the exception and then throw it:

1try {
2    echo 'Do stuff' . PHP_EOL;
3    throw new Exception('testing');
4} catch (Exception $e) {
5    echo 'do something with the exception' . PHP_EOL;
6    throw $e;
7} finally {
8    echo 'inside finally' . PHP_EOL;
9}

It seems we prevented the finally block from getting executed? Well, not exactly…

1Do stuff
2do something with the exception
3inside finally
4
5Fatal error: Uncaught exception 'Exception' with message 'testing' in...

In other words, the finally block gets executed each time, regardless of the result.

A new PHP version is about to be released. At the time I’m writing this blog PHP 5.5 is in beta 4.

Eager to see the updates, I’ve compiled the new beta version. The feature list is available at: http://www.php.net/manual/en/migration55.new-features.php

The generators are the most important feature..

Generating generators in PHP 5.5

A generator is basically a function that contains a call to “yield”.

Let’s take the example form php.net:

 1<?php
 2function xrange($start, $limit, $step = 1) {
 3   for ($i = $start; $i <= $limit; $i += $step) {
 4       yield $i;
 5   }
 6}
 7
 8echo 'Single digit odd numbers: ';
 9
10/* Note that an array is never created or returned,
11* which saves memory. */
12foreach (xrange(1, 9, 2) as $number) {
13   echo "$number ";
14}
15?>

Basically, the generator (xrange in this case), instead of returning an array, will return a value at a time, in order to be processed.

But wait… wasn’t this already possible before this version?

Generators before PHP 5.5

Before PHP 5.5 there were already Iterators:

 1<?php
 2
 3class xrange implements Iterator
 4{
 5    private $position = 0;
 6    private $start;
 7    private $limit;
 8    private $step;
 9
10    public function __construct($start, $limit, $step = 1)
11    {
12        $this->start = $start;
13        $this->limit = $limit;
14        $this->step = $step;
15        $this->position = 0;
16    }
17
18    function rewind()
19    {
20        $this->position = 0;
21    }
22
23    function current()
24    {
25        return $this->start + ($this->position * $this->step);
26    }
27
28    function key()
29    {
30        return $this->position;
31    }
32
33    function next()
34    {
35        ++$this->position;
36    }
37
38    function valid()
39    {
40        return $this->current() <= $this->limit;
41    }
42}
43
44echo 'Single digit odd numbers: ';
45
46/* Note that an array is never created or returned,
47 * which saves memory. */
48foreach (new xrange(2, 9, 2) as $number) {
49    echo "$number ";
50}
51?>

Beside the fact that the Iterator is an object with multiple properties, basically we can achieve the same result.

But why do we need generators then? Simple! Instead of using ~40 lines of code, we can simply use 5 to achieve the same goal.

Another interesting thing is that:

1get_class(printer());

will return Generator.

Basically, a generator returns an object of type Generator, and this object extends Iterator.

The major difference, as it is described on the php.net website, is that the generator can not be reset, basically it goes one way only.

Sending information to the generators

Yes, generators work both ways, but each generator only works in one particular direction. If the syntax above is for “producing” data, then the syntax below is only for “consuming” data.

The syntax for a “consumer” is simple:

 1<?php
 2function printer() {
 3    $counter = 0;
 4    while(true) {
 5        $counter++;
 6        $value = yield;
 7        echo $value . $counter . PHP_EOL;
 8    }
 9    echo ‘Never executed...' . PHP_EOL;
10}
11
12$printer = printer();
13$printer->send('Hello!');
14echo 'Something is happening over here...' . PHP_EOL;
15$printer->send('Hello!');
16?>

The output will be:

1Hello!1
2Something is happening over here...
3Hello!2

Basically, the value of yield can be used as any other value. What’s interesting is the while. On php.net is the folowing comment:

// Sends the given value to the
// generator as the result of
// the yield expression and
// resumes execution of the
// generator.

The loop is needed because the generator will stop after it processes the value and will only continue when a new value is received. If we remove the while, only the first value will be processed, regardless of how many times we’ll call send().

An interesting thing is that what comes after the loop will not be executed, that is in my case:
echo ‘Never executed…’ . PHP_EOL;

So, if it looks like a good place to release a resource (e.g. DB or file), in fact it isn’t, because that code will never get executed.

It seems useful for logging. Again, nothing that couldn’t have been done before, but now it allows for an easier approach.

I’ve found though something that doesn’t work:

 1<?php
 2function printer() {
 3    while(true) {
 4        echo yield . PHP_EOL;
 5    }
 6}
 7
 8$printer = printer();
 9$printer->send('Hello world!');
10
11foreach($printer as $line) {
12    echo $line . PHP_EOF;
13}

A little chaotic, isn’t it? But I was wondering what would happen:
Fatal error: Uncaught exception ‘Exception’ with message ‘Cannot rewind a generator that was already run’ in…

So, once send() is used on an iterator, you can’t use it as an iterator again. Of course, another one can be generated with:
printer();

What is more confusing is that Generator is a final class, so it can’t be extended, and if you try to instantiate it directly (although even if it worked it would be useless):
Catchable fatal error: The “Generator” class is reserved for internal use and cannot be manually instantiated in…

Conclusion

It is an interesting feature because it simplifies things a lot when you try to create an iterator.

Also the use of send() seems very interesting, not because it is doing something new, but because it is doing it easier.

On the other hand, I don’t like that there is the same syntax for both generator versions and even more that what is after the while is not getting executed. I think the syntax is a little confusing because there isn’t a clear difference between the two. On the other hand, this already exists in Python, so for inspirator the examples from this language can be used.