New features

PHP 5.3 includes a lot of new features. Some of them are new language features like namespaces, closures, exceptions chaining, jump labels etc., and even though these are very recommended to learn, they are not required. You can continue to write code as you are used to and chances are that it will still work (more about that in Legacy code).

What is important from new features is fixes are enhancements. For example new garbage collector and other fixes reduce memory usage and increases performance. There are also some new extensions like phar, sqlite3 and fileinfo and some libraries (like mysql or openssl) have some major improvements. Finally, Windows support is improved even further and now is expected to be even more production-ready.

Legacy code

Apparently the biggest problem is with legacy applications – somehow everyone just decided that because of all these new features, everything should break. If you’d look at backward incompatibility list here, you notice that not that much has changed. Or in other words – if your code was “correct” before upgrade, it will work fine with PHP 5.3 too. For example static and/or private setters, ereg and some more other features shouldn’t have been used in a first place as manual clearly stated that.

Personally I have upgraded around 10 projects to run on PHP 5.3, each took less than an hour. On my development machine I also have strict error reporting level so I even had to remove marked-as-deprecated code, but for larger part of code everything worked fine. Furthermore, some of that code has been written using PHP 4, a couple years ago, and it still worked just fine.

Debian…

As far as I’m aware of, main linux distros like Debian or Red Hat do not have PHP 5.3 in their stable repositories, which makes upgrading potentially very hard or impossible. I have come across this before – sysadmins do not want to install anything outside from stable, so the only option is to wait (that happened to me when PHP 5 was still not well adopted). This is probably the only reasonable argument to not switch to PHP 5.3, but only if you don’t have option to switch servers.

I’m lucky with this problem, because I do not administer servers, but still can request for any PHP version I want. If you do not have this option, maybe it’s time to switch hosting server provider? There can be different situations, but software version shouldn’t be a limiting factor, especially when new version is available and known to be stable enough. You can even use multiple PHP versions if switching server would require testing a lot of applications.

Why you should be using PHP 5.3 right now

Firstly because it has those new features, which mean that you can start to use them as an early adopter and benefit later. All second iteration frameworks (Zend Framework 2.0, Symfony 2.0, Lithium etc.) coming out late this year will use PHP 5.3 extensively, so knowing how namespaces work (I’d say they are the ones you need to look first) and how to utilize closures will mean that you can get going very quickly.

Doctrine 2.0 is probably the best example of why you should learn PHP 5.3 now – most of its features could be written in older versions too, but not as clean and easy to understand. And it’s already in alpha stage, so stable version might be coming out very soon and yet again – if you want to stay on top of your game, you need to know how it works and how to leverage all new features.

As mentioned above, because of new garbage collector implementation PHP 5.3 performs much better (benchmarks). From my personal tests I have noticed that Zend Framework uses much less memory, just because there is less memory leaks, Doctrine of course gets a big speed up too.

Conclusion

I’m yet unsure what is all that buzz about – PHP 5.3 is stable, way faster than previous versions and works with legacy code just fine. Considering that it has new core features, which will be expected from developers to be known in just a few months, I don’t see a reason why you shouldn’t use it. And if you have any questions you can just ask me directly on twitter.

Because of “Functional Programming” course I had in university, I love lambda functions. At first they seemed a little bit strange, but hey – in Haskell you write:

Input: map (\x => x*3) [1,2,3,4]
Output: [3,6,9,12]

No need to create for loops (which doesn’t exists in Haskell at all) and code is much more flexible. Functional languages allows creating functions which accepts functions as arguments, not only integers or floats. That’s why most functions are very short, but are very easily connectable together.

I think one the best examples of lambda functions usefulness is sorting. Image this scenario: $books collection holds books information and you need to sort it by title; author; publish year and author; publish city and title. How you are going to do it? It’s easy and you probably would write something like this:

// Sort by title
$books->sortByTitle('ASC');
// Sort by publisher year, author
$books->sortByPublishYear('DESC')->sortByAuthor('ASC');

However, it looks good and does work just fine, but it’s not very practical – you need to create functions for all keywords (title, author, publish year, etc.). You may argue, that __call() can be used and that’s absolutely true, but it’s even harder to maintain and code it, still usable though.

Nevertheless, 5.3 version of PHP introduces lambda functions (also called anonymous functions), which can simplify your work a lot (I haven’t tried running this code):

// Sort by book title
$books->sort(
    function ($book1, $book2)
    {
        return strcmp($book1->title, $book2->title);
    });
 
// Sort by publisher year, author
$books->sort(
    function ($book1, $book2)
    {
        if ($book1->publish_year == $book2->publish_year)
            return strcmp($book1->author, $book2->author);
 
        return strcmp($book2->publish_year, $book1->publish_year);
    });

It’s a little bit harder to read and maybe understand, but basically you can pass whatever comparison function you’d like. Sort function can use simple for-loop-inside-for-loop or usort and compare all elements with your function

Lambda functions are not replacement for __cal() and should be used cleverly, search and filtering with lambda functions is only one example of how useful they are. In short, lambda functions allows you to create small dynamic functions which can be used to expand and modify normal functions behaviour.