Not logged in | Login

My RSS » Planet PHP » September 2009

Feeds

245681 items (663 unread) in 24 feeds

CNN

MSNBC

MSNBC.com: U.S. News (8 unread)
MSNBC.com: Business (5 unread)
MSNBC.com: Technology & Science (3 unread)

PHP

PHPDeveloper.org
Planet PHP (39 unread)
Nettuts+ (18 unread)

Deals

Techbargains.com (20 unread)
dealnews - 20 most recent deals. (281 unread)
Buy.com - Today's Deals (11 unread)
xpBargains.com (232 unread)
GottaDeal.com - Why Pay Retail? (29 unread)

Tech

broadbandreports.com (1 unread)
BetaNews.Com (2 unread)

Web Development

CNN Money

Frugal Blogs

Frugal Dad
The Simple Dollar (1 unread)

Planet PHP

Monitoring and logging CPU Utilization of Virtual Machines in Xen

Posted: September 30th, 2009, 11:59pm MDT by John Lim (PHP Everywhere - By John Lim)
Recently we have been experimenting with the Xen hypervisor. In my testing, I have found that Linux performance is better on Xen than VMWare and we are considering it for Linux rollouts.
Normally when we roll out a new server for a customer, we have a simple PHP script installed as a cron job that runs vmstat and logs the CPU utilization of the server into our database every 5 minutes. It's very useful for benchmarking, monitoring and troubleshooting mysterious performance problems. I needed a similar script for Xen.
A search in Google revealed a Perl script by Tom Brown to record the Xen domain CPU utilisation.
However the following limitations led me to modify it:
- Does not work properly with multi-core CPUs. CPU utilisation can go over 100%.
- Unfortunately sleep() does not sleep for precisely the number of seconds you define causing the CPU utilization to go over 100% again. There is some perturbation, either because Dom-0 is still virtualised or some other reason.
- No easy way of logging to a database.
So i rewrote parts of the script and renamed in xenstat.pl (after vmstat). You can download xenstat.pl here. To use run "perl xenstat.pl" in domain 0. The following output will be generated, with a new statistic generated every 5 seconds:
```
       35_hobbes  0.35% cpu usage  15.29 sec over 0.02 days
     54_garuda_0  0.63% cpu usage  52.62 sec over 0.05 days
    59_gyrfalcon  0.69% cpu usage  57.39 sec over 0.05 days
           Dom-0  1.57% cpu usage  15358.39 sec over 5.68 days

                    35_hobb 54_garu 59_gyrf   Dom-0    Idle
2009-10-01 12:13:58     0.0     0.0     1.0     3.3    95.6
2009-10-01 12:14:04     0.0     0.0     0.2     7.3    92.4
2009-10-01 12:14:09     0.0     0.0     0.2     3.2    96.5
2009-10-01 12:14:14     0.0     0.0     0.2     3.1    96.6
```
In the above output, the first few lines summarise the CPUs and running domains. Then we have the statistics generated every 5 seconds.
You can also define the interval to poll (in seconds), and the number of samples just like vmstat:
```
[root@server ~]# perl xenstat.pl 3 2
cpus=2
       35_hobbes  0.34% cpu usage  15.32 sec over 0.03 days
     54_garuda_0  0.63% cpu usage  53.24 sec over 0.05 days
    59_gyrfalcon  0.68% cpu usage  57.74 sec over 0.05 days
           Dom-0  1.57% cpu usage  15362.69 sec over 5.68 days

                    35_hobb 54_garu 59_gyrf   Dom-0    Idle
2009-10-01 12:14:59     0.0     0.0     1.7     5.7    92.5
2009-10-01 12:15:02     0.0     0.0     0.3    10.4    89.3

[root@server ~]#
```
To log the CPU utilisation using the Perl script, I didn't want to install a database client in Dom-0. So I added another parameter, a URL to a web server to call with the CPU info as GET parameters. I assume wget is installed in your Dom-0.
```
[root@server ~]# perl xenstat.pl 10 1  [192.168.0.1] cpus=2
     54_garuda_0  0.49% cpu usage  3065.81 sec over 3.62 days
    59_gyrfalcon  3.62% cpu usage  5039.03 sec over 0.80 days
           Dom-0  1.57% cpu usage  9782.15 sec over 3.62 days


--10:46:42--  [192.168.0.1] Connecting to 192.168.0.1:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 498 [text/html]
Saving to: `STDOUT'

100%[============================================>] 498         --.-K/s   in 0s

10:46:42 (67.8 MB/s) - `-' saved [498/498]

2009-09-29 10:46:42  0  2  2 96
```
This will accumulate statistics for 10 seconds then send it to the above url in this format:
```
 [192.168.0.1] 
```
This allows you to log the data using a REST-ful web service.
I hope this is useful for anyone using Xen. This has been a good experience down memory lane too as I haven't coded in Perl for nearly 10 years!
Download xenstat.pl.
1 Oct 2009 changes:
```
# Now works correctly when guest vm is started or shutdown (xenstat.pl detects changes and resets itself).
# Fixed reboot handling - cpu usage will go negative
# Change cpu formating from %3d to %7.1f. Needed when you have large number of guest vm's.
# Added domain names every 20 lines.
# Changed name of Domain-0 to Dom-0 to fit better into header line.
# Switched to use HiRes sleep timer. Thanks Tim Thomas.
```
Other tools: see xentop, which can run in batch mode, but cannot post to web server.
The original script written by Tom Brown.
Monitoring and logging CPU Utilization of Virtual Machines in Xen

Posted: September 30th, 2009, 10:21pm MDT by John Lim (PHP Everywhere - By John Lim)
Recently we have been experimenting with the Xen hypervisor. In my testing, I have found that Linux performance is better on Xen than VMWare and we are considering it for Linux rollouts.
Normally when we roll out a new server for a customer, we have a simple PHP script installed as a cron job that runs vmstat and logs the CPU utilization of the server into our database every 5 minutes. It's very useful for benchmarking, monitoring and troubleshooting mysterious performance problems. I needed a similar script for Xen.
A search in Google revealed a Perl script by Tom Brown to record the Xen domain CPU utilisation.
However the following limitations led me to modify it:
- Does not work properly with multi-core CPUs. CPU utilisation can go over 100%.
- Unfortunately sleep() does not sleep for precisely the number of seconds you define causing the CPU utilization to go over 100% again. There is some perturbation, either because Dom-0 is still virtualised or some other reason.
- No easy way of logging to a database.
So i rewrote parts of the script and renamed in xenstat.pl (after vmstat). You can download xenstat.pl here. To use run "perl xenstat.pl" in domain 0. The following output will be generated, with a new statistic generated every 5 seconds:
```
       35_hobbes  0.35% cpu usage  15.29 sec over 0.02 days
     54_garuda_0  0.63% cpu usage  52.62 sec over 0.05 days
    59_gyrfalcon  0.69% cpu usage  57.39 sec over 0.05 days
           Dom-0  1.57% cpu usage  15358.39 sec over 5.68 days

                    35_hobb 54_garu 59_gyrf   Dom-0    Idle
2009-10-01 12:13:58     0.0     0.0     1.0     3.3    95.6
2009-10-01 12:14:04     0.0     0.0     0.2     7.3    92.4
2009-10-01 12:14:09     0.0     0.0     0.2     3.2    96.5
2009-10-01 12:14:14     0.0     0.0     0.2     3.1    96.6
```
In the above output, the first few lines summarise the CPUs and running domains. Then we have the statistics generated every 5 seconds.
You can also define the interval to poll (in seconds), and the number of samples just like vmstat:
```
[root@server ~]# perl xenstat.pl 3 2
cpus=2
       35_hobbes  0.34% cpu usage  15.32 sec over 0.03 days
     54_garuda_0  0.63% cpu usage  53.24 sec over 0.05 days
    59_gyrfalcon  0.68% cpu usage  57.74 sec over 0.05 days
           Dom-0  1.57% cpu usage  15362.69 sec over 5.68 days

                    35_hobb 54_garu 59_gyrf   Dom-0    Idle
2009-10-01 12:14:59     0.0     0.0     1.7     5.7    92.5
2009-10-01 12:15:02     0.0     0.0     0.3    10.4    89.3

[root@server ~]#
```
To log the CPU utilisation using the Perl script, I didn't want to install a database client in Dom-0. So I added another parameter, a URL to a web server to call with the CPU info as GET parameters. I assume wget is installed in your Dom-0.
```
[root@server ~]# perl xenstat.pl 10 1  [192.168.0.1] cpus=2
     54_garuda_0  0.49% cpu usage  3065.81 sec over 3.62 days
    59_gyrfalcon  3.62% cpu usage  5039.03 sec over 0.80 days
           Dom-0  1.57% cpu usage  9782.15 sec over 3.62 days


--10:46:42--  [192.168.0.1] Connecting to 192.168.0.1:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 498 [text/html]
Saving to: `STDOUT'

100%[============================================>] 498         --.-K/s   in 0s

10:46:42 (67.8 MB/s) - `-' saved [498/498]

2009-09-29 10:46:42  0  2  2 96
```
This will accumulate statistics for 10 seconds then send it to the above url in this format:
```
 [192.168.0.1] 
```
This allows you to log the data using a REST-ful web service.
I hope this is useful for anyone using Xen. This has been a good experience down memory lane too as I haven't coded in Perl for nearly 10 years!
Download xenstat.pl.
1 Oct 2009 changes:
```
# Now works correctly when guest vm is started or shutdown (xenstat.pl detects changes and resets itself).
# Fixed reboot handling - cpu usage will go negative
# Change cpu formating from %3d to %7.1f. Needed when you have large number of guest vm's.
# Added domain names every 20 lines.
# Changed name of Domain-0 to Dom-0 to fit better into header line.
```
Other tools: see xentop, which can run in batch mode, but cannot post to web server.
The original script written by Tom Brown.
OAuth No Guarantee Against Nefarious Behavior

Posted: September 30th, 2009, 4:00pm MDT by Brandon Savage

Twitter has implemented the OAuth login system, allowing for users to centrally control what sites have access to their Twitter accounts, without having to share their passwords with the third parties. This improvement means that there is less risk of the full account credentials being used nefariously, since the user has to log into the session and explicitly authorize the behavior.

But this doesn’t mean that individuals are completely safe from nefarious behavior at the hands of third-party application providers.

Take for example Twibbon. Twibbon is a service that allows you to place a badge on your Twitter icon. Many of my followers have used Twibbon to decorate with sports teams, frameworks they prefer, or other icons. I even used it to add a Clemson tiger paw to my icon for a bit. But Twibbon is evil.

But Twibbon does some pretty uncool things. First, as soon as you add the icon they post a tweet “on your behalf” announcing that you use Twibbon and suggesting that your followers should, too. They do not, of course, give the option to opt out of this behavior. That’s strike one.

Strike two was the discovery today that Twibbon also adds themselves to your follower list. That’s right – without asking, they automatically follow themselves with your account. This behavior is not well disclosed, either, nor can you opt out.

But for the third strike, they had to go one step further and do something completely nefarious and rude: they also take the liberty of marking their Twitter updates as updates that should be sent out via SMS. I discovered this trick when I was examining the list of people that I follow. I don’t have any updates sent to me via SMS, except for direct messages, because I don’t like using my text messages when I can just read tweets on my iPhone for free (using Tweetie).

Technically, Twibbon discloses most of this behavior. In little tiny letters, they tell you that they are going to tweet on your behalf and have you follow them. But the do not disclose that they will be signing you up for SMS updates.

Services like Twibbon provide value to Twitter, but they cannot be allowed to simply opt you into their marketing schemes on a whim. Not when they’re given read and write access to your account. OAuth helps keep nefarious behavior in check, but doesn’t prevent it altogether. Twitter needs to do more to ensure that services like Twibbon disclose and allow for the opt-out of these kinds of actions.
CodeWorks '09 - Atlanta

Posted: September 30th, 2009, 12:17pm MDT by Chuck Burgess

CodeWorks '09 - Atlanta
js-test-driver Phing task

Posted: September 30th, 2009, 9:08am MDT by Jakob Westhoff

In my need of a cross-browser javascript unit-testing framework, which can be run from the commandline I discovered js-test-driver. I soon realized to be able to productively use this framework I needed to integrate the test run into the used build process. As Phing is used for building I needed a simple Phing task to run js-test-driver tests.
Pair Programming: Where Teamwork Comes Out

Posted: September 29th, 2009, 11:00pm MDT by Brandon Savage

The New York Times did a profile on the topic of pair programming, the art of writing software with a partner. They looked at it through the eyes of an individual who does pair programming every day.

The profile is pretty good, and makes a strong case for pair programming. While I’m not fully prepared to surrender my freedom to another person for 100% full-time pair programming, I think that doing pair programming is something that can be very effective.

One thing that the New York Times doesn’t really play up is that pair programming is good for management. This is sometimes lost on management, who wonders why they should use two programmers to do the work of one. They miss the point, though, when they do the math. First, a second programmer provides a second set of eyes, meaning that bugs are reduced. Fixing bugs takes time, and this reduction in bugs actually saves time. Second, management also misses the fact that two people put in eight hours of productivity each day, together, rather than perhaps four hours total, if they were programming separately. This is due to the fact that programmers get bored, get distracted, or generally get off task, but with another person there is a peer pressure to keep working.

At the end of the day, even if the lines of code written are lower, the problems solved, bugs avoided, and logic worked out is of higher quality and improved stability. For those who have never tried pair programming, I highly recommend it.
Microsoft promotes the careers of PHP professionals

Posted: September 29th, 2009, 9:43pm MDT by PHP Classes

Microsoft promotes the careers of PHP professionals By Manuel Lemos Microsoft is launching a new initiative to promote the careers of PHP professionals.

This article presents an interview with a Microsoft manager to explain in more details what is this initiative and how the PHP professionals may take advantage of it.
CodeWorks

Posted: September 29th, 2009, 9:37pm MDT by Jason E. Sweat

I am winding down my “tour of duty” with the MTA crew for CodeWorks 2009. This is a really ambitious adventure, seven cities in two weeks. I was a member of the A-Team, doing 3 hour long tutorials on the first day of each city, while the B-Team was arriving. The following [...]
The Mysteries Of Asynchronous Processing With PHP - Part 2: Making Zend Framework Applications CLI Accessible

Posted: September 29th, 2009, 7:19pm MDT by Pádraic Brady

In Part 1 of this series, we started an exploration of the concept of Asynchronous Processing as it applied to PHP. We covered the benefits it offers, the basic implementation directions often applied, and also discussed how to identify and separate tasks from the main application so they could be made subject to asynchronous processing. It is highly recommended that you read this before continuing with Part 2 so you can follow what I'm up to here .

UPDATE: Modified the bootstrap class and script based ZF runner to reflect some changes needed to support Part 3 of this series. These primarily allow for improved control over command line options.

With the theory heavy portion of the series out of the way, we can begin to explore the various implementation possibilities. In Part 3, we will examine implementing Asynchronous Processing using a child process, i.e. a separate PHP process we create from our application during a request. We'll analyse this implementation option before introducing some source code so we may understand its advantages and disadvantages.

While, technically, this series is not Zend Framework specific since the same principles can be applied to any PHP application, I'll be using the Zend Framework in examples of asynchronous processing from an application. As a result, Part 2 is a tangential detour into how to make a Zend Framework based application accessible from the command line before we delve into examples using this in future parts of the series. If you are not a Zend Framework user, I'm sure you can find relevant material online for your own preferred framework though the ZF pieces may still have some usefulness in understanding the approach from an MVC perspective.

Surprising to some, the Zend Framework is indeed usable from the command line...with some massaging. I've already noted that using a full application framework for a background task comes at a cost since you are using a lot of code, not all of which may be strictly necessary but unless you are willing to invest in a custom framework specifically for such uses, your framework of choice is probably the simplest option.

I'm not going to describe setting up a basic application with the Zend Framework, however you can do so by following the base application created in my book, Zend Framework: Surviving The Deep End (which is free, online in html form, and now duly advertised to you ). The relevant chapters are Chapter 5 and Chapter 6. If you want to get started quickly, you can download the example application for the book (in progress) from [github.com]

Unfortunately, the ZF is not immediately accessible from the command line. Although it offers classes like Zend_Console_Getopt and Zend_Controller_Response_Cli, the remaining pieces are mysteriously (and conspicuously) missing. They are not difficult to add however, especially if you are using Zend_Application to fuel your bootstrapping.

Adding Custom CLI Support Classes
There are two very obvious problems calling a Zend Framework application from the command line. First, there is no Request class supporting CLI command line options (though there is a Zend_Controller_Request_Simple). Secondly, the Front Controller always attempts to route the request, and all of the standard Routers assume you will use a HTTP request. This HTTP focus results in an Exception when routing occurs.

To improve this situation, we will implement two very simple custom classes. ZFExt_Controller_Request_Cli and ZFExt_Controller_Router_Cli.

ZFExt_Controller_Request_Cli very simply accepts an instance Zend_Console_Getopt and attempts to locate a module, controller and action name from the command line options it exposes. If they exist, these are used to set the relevant module, controller and action names for the request (doing this manually negates the need for routing). Here's the class stored to (if using the example app) at /library/ZFExt/Controller/Request/Cli.php:

Truncated by Planet PHP, read more at the original (another 38945 bytes)
PHPBenelux Conference - Call for Papers

Posted: September 29th, 2009, 12:30pm MDT by Zend Developer Zone

A brand new conference is on the horizon! PHP Benelux, one of the largest PHP user groups, is hosting a conference of their own in Antwerp, Belgium, on Saturday January 30th. They’ve announced their Call for Papers is open until October 31st.
The Mysteries Of Asynchronous Processing With PHP - Part 2: Making Zend Framework Applications CLI Accessible

Posted: September 29th, 2009, 11:33am MDT by Pádraic Brady

In Part 1 of this series, we started an exploration of the concept of Asynchronous Processing as it applied to PHP. We covered the benefits it offers, the basic implementation directions often applied, and also discussed how to identify and separate tasks from the main application so they could be made subject to asynchronous processing. It is highly recommended that you read this before continuing with Part 2 so you can follow what I'm up to here .

With the theory heavy portion of the series out of the way, we can begin to explore the various implementation possibilities. In Part 3, we will examine implementing Asynchronous Processing using a child process, i.e. a separate PHP process we create from our application during a request. We'll analyse this implementation option before introducing some source code so we may understand its advantages and disadvantages.

While, technically, this series is not Zend Framework specific since the same principles can be applied to any PHP application, I'll be using the Zend Framework in examples of asynchronous processing from an application. As a result, Part 2 is a tangential detour into how to make a Zend Framework based application accessible from the command line before we delve into examples using this in future parts of the series. If you are not a Zend Framework user, I'm sure you can find relevant material online for your own preferred framework though the ZF pieces may still have some usefulness in understanding the approach from an MVC perspective.

Surprising to some, the Zend Framework is indeed usable from the command line...with some massaging. I've already noted that using a full application framework for a background task comes at a cost since you are using a lot of code, not all of which may be strictly necessary but unless you are willing to invest in a custom framework specifically for such uses, your framework of choice is probably the simplest option.

I'm not going to describe setting up a basic application with the Zend Framework, however you can do so by following the base application created in my book, Zend Framework: Surviving The Deep End (which is free, online in html form, and now duly advertised to you ). The relevant chapters are Chapter 5 and Chapter 6. If you want to get started quickly, you can download the example application for the book (in progress) from [github.com]

Unfortunately, the ZF is not immediately accessible from the command line. Although it offers classes like Zend_Console_Getopt and Zend_Controller_Response_Cli, the remaining pieces are mysteriously (and conspicuously) missing. They are not difficult to add however, especially if you are using Zend_Application to fuel your bootstrapping.

Adding Custom CLI Support Classes
There are two very obvious problems calling a Zend Framework application from the command line. First, there is no Request class supporting CLI command line options (though there is a Zend_Controller_Request_Simple). Secondly, the Front Controller always attempts to route the request, and all of the standard Routers assume you will use a HTTP request. This HTTP focus results in an Exception when routing occurs.

To improve this situation, we will implement two very simple custom classes. ZFExt_Controller_Request_Cli and ZFExt_Controller_Router_Cli.

ZFExt_Controller_Request_Cli very simply accepts an instance Zend_Console_Getopt and attempts to locate a module, controller and action name from the command line options it exposes. If they exist, these are used to set the relevant module, controller and action names for the request (doing this manually negates the need for routing). Here's the class stored to (if using the example app) at /library/ZFExt/Controller/Request/Cli.php:

<?php

require_once 'Zend/Controller/Request/Abstract.php';

Truncated by Planet PHP, read more at the original (another 35609 bytes)
ConFoo.ca - Call for Papers

Posted: September 29th, 2009, 10:03am MDT by Zend Developer Zone

ConFoo.ca, the spiritual successor to PHP Quebec, is happening March 10-12, 2010, and has announced their Call for Papers is open until November 13th.
The ZendCon Sessions Episode 26: Security Centered Design

Posted: September 29th, 2009, 9:17am MDT by Zend Developer Zone

Presenting the latest edition of The ZendCon Sessions. The podcast that rebroadcasts sessions/talks from the last ZendCon PHP Conference. This episode of The ZendCon Sessions was recorded live at ZendCon 2008 in Santa Clara, CA and features Chris Shiflett giving his talk: “Security Centered Design”
The ZendCon Sessions Episode 27: Security Centered Design

Posted: September 29th, 2009, 9:17am MDT by Zend Developer Zone

Presenting the latest edition of The ZendCon Sessions. The podcast that rebroadcasts sessions/talks from the last ZendCon PHP Conference. This episode of The ZendCon Sessions was recorded live at ZendCon 2008 in Santa Clara, CA and features Chris Shiflett giving his talk: “Security Centered Design”
PHP Security: Are you paying attention?

Posted: September 29th, 2009, 8:15am MDT by Rafael Dohms

Security is a recurring topic when the talk is about Technology, or any other area for that matter. To take security for granted when you are developing an application, as simple as it may be, is a huge mistake which can take a turn for the worse. I have ran into lots of excuses for ignoring security in the past, one of them is the recurring “This is just a simple application, it has no sensitive data”, this may be a valid point for the person repeating it like a mantra, especially because this person is generally suffering of great pressures , short timeframes and a lack of proper management ready to deal with web development. Cal Evans in his Open Teams session gives a perfect example of this when he tells us about a project with an impossible due date. Upon questioning the due date to the marketing department their reply was straight forward: “Because that’s when the brochures are done”. This is an example of the lack of perception around web development and all the issues we need to take into consideration when developing applications.

Whatever the reason is for neglecting security the consequences can escalate much higher then the “non-sensitive data” of the application. I can cite a recent example that happened to one of the biggest Brazilian mobile companies. A simple issue was found in a file called popup.php, the objective of the file fits into the excuse mentioned above, it just had to append the company logo and load a given file’s content into a popup window.

Doing a little play my part simulation we can easily imagine that the need for this page probably started in the <insert non-tech department> and got to the tech department with urgent priority, usually on a Friday EOD, when the manager is leaving and the developers are just waiting for the boss to leave in order to get to the closest bar for a happy hour. In the rush of things neglecting security and any other management process the order is “just do it”. This generally leads to the easiest way out, so that whatever purpose the fix fits will be live before the weekend. No problem you say, “leave it like that during the weekend and redo it on Monday following the proper protocols”, that’s iffy behavior none the less, but in a real world example this feature will only be revisited on one occasion: the day it does an EPIC FAIL.

Doing a post-mortem analysis on the flaw i described, we can easily find out what happened. The final URL used by the popup.php file had a “url” GET var attached to it, the value usually pointed to another html or PHP file. This was the first indication that this was a sleeping time bomb, so the first thing someone tried was to point that to a file, any file that would be “unexpected”, like so:

The result of this request exploded directly into our face 2 security issues overlooked by the developer. Can you guess which ones?

Ok, so the first mistake here was leaving display_errors on, lack of doing so now shows us the second mistake which can be one or two depending on how you think of it. The obvious on is neglecting the security karma everyone needs to know whick is: “Filter input, escape output”. Obviously since he actually executed a include on the file given we can say that he did not check in any way the value provided in the “url” parameter, in the least he should have checked if it was still in the site’s file tree.

To make this exploit something dangerous you just need to start passing it usual sensitive linux files, like /etc/passwd or try to load the apache [httpd.conf] file, which BTW actually worked

Analysing these files showed that the issue was really bad, the actual site really had few valuable information, but it did show that the server had much more on it then just this simple site, hence the EPIC FAIL and domino effect of compromising all systems on that machine. Another factor makes this become epic, Twitter. This flaw was only fi
Truncated by Planet PHP, read more at the original (another 4509 bytes)
PHPNW09: Weekend of PHP and Fun

Posted: September 29th, 2009, 8:02am MDT by Lorna Mitchell

Having just put the finishing touches to the schedule for PHPNW09, I'm realising just how excited I am about this event coming up in less than a fortnight. This is the second year we've run the event, and its bigger and better than last year - and I know what a great crowd to expect! We kick off in Manchester on Friday 9th October for a pre-conference social, with the main event on Saturday and follow this, naturally, with another party! Since so many people are there for the weekend we've also taken some conference space for Sunday morning and begged a few more speakers to hang around and share their knowledge with those people who are staying for the weekend. (The Sunday speakers get no speaker package and they were all very gracious about having their arms twisted ... we can't thank them enough!)

The full schedule is now published with both Saturday and Sunday sessions now published along with timings for each. Although this is a local conference with a budget ticket price and organised by volunteers, the lineup would not look out of place at any other event on the PHP calendar - and we'd like to thank all the speakers that submitted talks to us, regardless of whether we managed to find time in the schedule for them. The submitters, the speakers, the helpers and the attendees are what makes this conference what it is - and I can't wait! See you in Manchester :)
Monitoring and logging CPU Utilization of Virtual Machines in Xen

Posted: September 29th, 2009, 3:40am MDT by John Lim (PHP Everywhere - By John Lim)
Recently we have been experimenting with the Xen hypervisor. In my testing, I have found that Linux performance is better on Xen than VMWare and we are considering it for Linux rollouts.
Normally when we roll out a new server for a customer, we have a simple PHP script installed as a cron job that runs vmstat and logs the CPU utilization of the server into our database every 5 minutes. It's very useful for benchmarking, monitoring and troubleshooting mysterious performance problems. I needed a similar script for Xen.
A search in Google revealed a Perl script by Tom Brown to record the Xen domain CPU utilisation.
However the following limitations led me to modify it:
- Does not work properly with multi-core CPUs. CPU utilisation can go over 100%.
- Unfortunately sleep() does not sleep for precisely the number of seconds you define causing the CPU utilization to go over 100% again. There is some perturbation, either because Dom-0 is still virtualised or some other reason.
- No easy way of logging to a database.
So i rewrote parts of the script and renamed in xenstat.pl (after vmstat). You can download xenstat.pl here. To use run "perl xenstat.pl" in domain 0. The following output will be generated, with a new statistic generated every 5 seconds:
```
cpus=2
     54_garuda_0  0.49% cpu usage  3034.56 sec over 3.61 days
    59_gyrfalcon  3.65% cpu usage  5032.13 sec over 0.80 days
        Domain-0  1.56% cpu usage  9746.05 sec over 3.61 days

2009-09-29 10:38:12 39  1 37 23
2009-09-29 10:38:17 80  0  7 13
2009-09-29 10:38:22 54  0  4 42
2009-09-29 10:38:28 25  1  3 71
```
In the above output, the first few lines summarise the CPUs and running domains. Then we have the statistics generated every 5 seconds:
```
 DATE       TIME       GARUDA   GYRFALCON DOM0  IDLE
                       CPU%     CPU%      CPU%  CPU%

2009-09-29  10:38:12    39       1         37    23
```
You can also define the interval to poll (in seconds), and the number of samples just like vmstat:
```
[root@server ~]# perl xenstat.pl 3 2
cpus=2
     54_garuda_0  0.49% cpu usage  3064.51 sec over 3.61 days
    59_gyrfalcon  3.63% cpu usage  5034.60 sec over 0.80 days
        Domain-0  1.57% cpu usage  9775.78 sec over 3.61 days

2009-09-29 10:42:26  0  0  4 96
2009-09-29 10:42:29  0  2  4 94
[root@server ~]#
```
To log the CPU utilisation using the Perl script, I didn't want to install a database client in Dom-0. So I added another parameter, a URL to a web server to call with the CPU info as GET parameters. I assume wget is installed in your Dom-0.
```
[root@server ~]# perl xenstat.pl 10 1  [192.168.0.1] cpus=2
     54_garuda_0  0.49% cpu usage  3065.81 sec over 3.62 days
    59_gyrfalcon  3.62% cpu usage  5039.03 sec over 0.80 days
        Domain-0  1.57% cpu usage  9782.15 sec over 3.62 days


--10:46:42--  [192.168.0.1] Connecting to 192.168.0.1:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 498 [text/html]
Saving to: `STDOUT'

100%[=====================================================================================>] 498         --.-K/s   in 0s

10:46:42 (67.8 MB/s) - `-' saved [498/498]

2009-09-29 10:46:42  0  2  2 96
```
This will accumulate statistics for 10 seconds then send it to the above url in this format:
```
 [192.168.0.1] 
```
This allows you to log the data using a REST-ful web service.
I hope this is useful for anyone using Xen. This has been a good experience down memory lane too as I haven't coded in Perl for nearly 10 years!
Download xenstat.pl.
Other tools: see xentop, which can run in batch mode, but cannot post to web server.
The original script written by Tom Brown.
Build a Lifestream with SimplePie

Posted: September 29th, 2009, 3:11am MDT by SitePoint Â» PHP
If you’re like me, you have bits and pieces of your online life scattered absolutely everywhere — photos, comments, tweets, blogs, favorite links — stashed away in all kinds of profiles. And, of course, many of those profiles offer RSS feeds, ripe for the mashing. Wouldn’t it be nice to aggregate all those on one page? I think so!

In this tutorial we’ll build a page that gathers up the RSS feeds of all those little bits of your life and presents them all together in one spot. To do that, we’ll use SimplePie, a feed parsing class written in PHP. It’s powerful, it’s open source, and it’s easy to use. We’ll then hack on the output a little, and make it all look gorgeous with html and CSS. The techniques we’ll cover are also useful if you find that you need to aggregate RSS from many sources, like a news page. Let’s begin!
What You’ll Need
- The SimplePie library.
- A web server that’s capable of running it — there’s a compatibility test in the SimplePie package that will tell you whether your server is good to go.
- If you tweet, grab this function by Alison Gianotto to help auto-link those tweets
- Of course, you’ll need your trusty text editor!
- For brevity, some of the code is excluded from this tutorial. If you want to see the full picture, view the completed example or download it.
Let’s Begin
First, of course, we’ll need to identify the feeds we want to include on the page. Like I said, I have profiles in lots of places, but for now I’ll keep it short and sweet — I’ll grab my blog, Twitter, Flickr photos, and favorited tracks from Last.fm.

You’ll need to gather up the URLs for the feeds you want, and stash them someplace safe. To do that, look for RSS icons on the page or in your browser’s address bar. Paste those URLs in a text file for later reference.

Next, we’ll need to check that SimplePie is compatible with our hosting environment. There’s plenty of stuff in this download — for now, we can just upload the compatibility_test directory in a web-accessible location on the server, and take a look at it in a web browser. Hopefully, there’ll be a series of messages informing you that a number of dependencies are enabled. If so, it’s time to upload the rest of the library. (If you have a folder in your download called test, it’s safe to exclude that one.)

While you’re poking around in your web server, now’s a good time to set up a directory for SimplePie to use as a cache. You should make this directory writable. I’ve chosen cache.

Make a note of where you uploaded SimplePie, and your cache directory. In my case, both are in the same directory as where I plan to put my lifestream page.
Prepare Your Feeds
Let’s grab those feeds! Open up a new text editor and begin a new PHP file, which we’ll call lifestream.php. This will be the page that eventually shows our lifestream.

First, let’s include a very important component — the SimplePie library itself:
```
<?php
  require_once('./simplepie/simplepie.inc');
```
Now, we need to define a couple of important variables: the first is to define the cache location, and the second is to specify the amount of time (in seconds) we want to cache the feeds. Hitting feeds repeatedly is rude, and some feed providers will bar you for excessive feed requests. Also, if you have a busy site, it’s sensible to keep your resource consumption low. I’ve chosen thirty minutes, or 1800 seconds, which is a nice tradeoff between freshness and politeness. Here are those variables:
```
$cache = "./cache";
$duration = 1800;
```
Next, time to create some SimplePie objects. The easiest way to turn a feed into a SimplePie object is to call it in its short form: pass it a feed URL, the location of your cache directory, and the cache duration. All my objects look roughly like this:
```
$object = new SimplePie(
 "http://example.com/fee
```
Truncated by Planet PHP, read more at the original (another 8648 bytes)
Monitoring and logging CPU Utilization of Virtual Machines in Xen

Posted: September 28th, 2009, 11:38pm MDT by John Lim (PHP Everywhere - By John Lim)
Recently we have been experimenting with the Xen hypervisor. In my testing, I have found that Linux performance is better on Xen than VMWare and we are considering it for Linux rollouts.
Normally when we roll out a new server for a client, we have a simple PHP script installed as a cron job that logs the CPU utilization of the server into our database every 5 minutes. It's very useful for benchmarking, monitoring and troubleshooting mysterious performance problems. I needed a similar script for Xen.
A search in Google revealed a Perl script by Tom Brown to record the Xen domain CPU utilisation.
However the following limitations led me to modify it:
- Does not work properly with multi-core CPUs. CPU utilisation can go over 100%.
- Unfortunately sleep() does not sleep for precisely the number of seconds you define causing the CPU utilization to go over 100% again. There is some perturbation, either because Dom-0 is still virtualised or some other reason.
- No easy way of logging to a database.
So i rewrote parts of the script and renamed in xenstat.pl (after vmstat). You can download xenstat.pl here. To use run "perl xenstat.pl" in domain 0. The following output will be generated, with a new statistic generated every 5 seconds:
```
cpus=2
     54_garuda_0  0.49% cpu usage  3034.56 sec over 3.61 days
    59_gyrfalcon  3.65% cpu usage  5032.13 sec over 0.80 days
        Domain-0  1.56% cpu usage  9746.05 sec over 3.61 days

2009-09-29 10:38:12 39  1 37 23
2009-09-29 10:38:17 80  0  7 13
2009-09-29 10:38:22 54  0  4 42
2009-09-29 10:38:28 25  1  3 71
```
In the above output, the first few lines summarise the CPUs and running domains. Then we have the statistics generated every 5 seconds:
```
 DATE       TIME       GARUDA   GYRFALCON DOM0  IDLE
                       CPU%     CPU%      CPU%  CPU%

2009-09-29  10:38:12    39       1         37    23
```
You can also define the interval to poll (in seconds), and the number of samples just like vmstat:
```
[root@server ~]# perl xenstat.pl 3 2
cpus=2
     54_garuda_0  0.49% cpu usage  3064.51 sec over 3.61 days
    59_gyrfalcon  3.63% cpu usage  5034.60 sec over 0.80 days
        Domain-0  1.57% cpu usage  9775.78 sec over 3.61 days

2009-09-29 10:42:26  0  0  4 96
2009-09-29 10:42:29  0  2  4 94
[root@server ~]#
```
To log the CPU utilisation using the Perl script, I didn't want to install a database client in Dom-0. So I added another parameter, a URL to a web server to call with the CPU info as GET parameters. I assume wget is installed in your Dom-0.
```
[root@server ~]# perl xenstat.pl 10 1  [192.168.0.1] cpus=2
     54_garuda_0  0.49% cpu usage  3065.81 sec over 3.62 days
    59_gyrfalcon  3.62% cpu usage  5039.03 sec over 0.80 days
        Domain-0  1.57% cpu usage  9782.15 sec over 3.62 days


--10:46:42--  [192.168.0.1] Connecting to 192.168.0.1:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 498 [text/html]
Saving to: `STDOUT'

100%[=====================================================================================>] 498         --.-K/s   in 0s

10:46:42 (67.8 MB/s) - `-' saved [498/498]

2009-09-29 10:46:42  0  2  2 96
```
This will accumulate statistics for 10 seconds then send it to the above url. This allows you to log the data using a REST-ful web service.
I hope this is useful for anyone using Xen. This has been a good experience down memory lane too as I haven't coded in Perl for nearly 10 years!
Download xenstat.pl.
Other tools: see xentop, which can run in batch mode, but cannot post to web server.
The original script written by Tom Brown.
Monitoring CPU Utilization of Virtual Machines in Xen

Posted: September 28th, 2009, 10:19pm MDT by John Lim (PHP Everywhere - By John Lim)
Recently we have been experimenting with the Xen hypervisor. In my testing, I have found that Linux performance is better on Xen than VMWare and we are considering it for Linux rollouts.
Normally when we roll out a new server for a client, we have a simple PHP script installed as a cron job that logs the CPU utilization of the server into our database every 5 minutes. It's very useful for benchmarking, monitoring and troubleshooting mysterious performance problems. I needed a similar script for Xen.
A search in Google revealed a Perl script by Tom Brown to record the Xen domain CPU utilisation.
However the following limitations led me to modify it:
- Does not work properly with multi-core CPUs. CPU utilisation can go over 100%.
- Unfortunately sleep() does not sleep for precisely the number of seconds you define causing the CPU utilization to go over 100% again. There is some perturbation, either because Dom-0 is still virtualised or some other reason.
- No easy way of logging to a database.
So i rewrote parts of the script and renamed in xenstat.pl (after vmstat). You can download xenstat.pl here. To use run "perl xenstat.pl" in domain 0. The following output will be generated, with a new statistic generated every 5 seconds:
```
cpus=2
     54_garuda_0  0.49% cpu usage  3034.56 sec over 3.61 days
    59_gyrfalcon  3.65% cpu usage  5032.13 sec over 0.80 days
        Domain-0  1.56% cpu usage  9746.05 sec over 3.61 days

2009-09-29 10:38:12 39  1 37 23
2009-09-29 10:38:17 80  0  7 13
2009-09-29 10:38:22 54  0  4 42
2009-09-29 10:38:28 25  1  3 71
```
In the above output, the first few lines summarise the CPUs and running domains. Then we have the statistics generated every 5 seconds:
```
 DATE       TIME       GARUDA   GYRFALCON DOM0  IDLE
                       CPU%     CPU%      CPU%  CPU%

2009-09-29  10:38:12    39       1         37    23
```
You can also define the interval to poll (in seconds), and the number of samples just like vmstat:
```
[root@server ~]# perl xenstat.pl 3 2
cpus=2
     54_garuda_0  0.49% cpu usage  3064.51 sec over 3.61 days
    59_gyrfalcon  3.63% cpu usage  5034.60 sec over 0.80 days
        Domain-0  1.57% cpu usage  9775.78 sec over 3.61 days

2009-09-29 10:42:26  0  0  4 96
2009-09-29 10:42:29  0  2  4 94
[root@server ~]#
```
To log the CPU utilisation using the Perl script, I didn't want to install a database client in Dom-0. So I added another parameter, a URL to a web server to call with the CPU info as GET parameters. I assume wget is installed in your Dom-0.
```
[root@server ~]# perl xenstat.pl 10 1  [192.168.0.1] cpus=2
     54_garuda_0  0.49% cpu usage  3065.81 sec over 3.62 days
    59_gyrfalcon  3.62% cpu usage  5039.03 sec over 0.80 days
        Domain-0  1.57% cpu usage  9782.15 sec over 3.62 days


--10:46:42--  [192.168.0.1] Connecting to 192.168.0.1:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 498 [text/html]
Saving to: `STDOUT'

100%[=====================================================================================>] 498         --.-K/s   in 0s

10:46:42 (67.8 MB/s) - `-' saved [498/498]

2009-09-29 10:46:42  0  2  2 96
```
This will accumulate statistics for 10 seconds then send it to the above url. This allows you to log the data using a REST-ful web service.
I hope this is useful for anyone using Xen. This has been a good experience down memory lane too as I haven't coded in Perl for nearly 10 years!
Download xenstat.pl.
Other tools: see xentop, which can run in batch mode, but cannot post to web server.
The original script written by Tom Brown.
Monitoring CPU Utilization of Virtual Machines in Xen

Posted: September 28th, 2009, 9:27pm MDT by John Lim (PHP Everywhere - By John Lim)
Recently we have been experimenting with the Xen hypervisor. In my testing, I have found that Linux performance is better on Xen than VMWare and we are considering it for Linux rollouts.
Normally when we roll out a new server for a client, we have a simple PHP script installed as a cron job that logs the CPU utilization of the server into our database every 5 minutes. It's very useful for benchmarking, monitoring and troubleshooting mysterious performance problems. I needed a similar script for Xen.
A search in Google revealed a Perl script by Tom Brown to record the Xen domain CPU utilisation.
However the following limitations led me to modify it:
- Does not work properly with multi-core CPUs. CPU utilisation can go over 100%.
- Unfortunately sleep() does not sleep for precisely the number of seconds you define causing the CPU utilization to go over 100% again. There is some perturbation, either because Dom-0 is still virtualised or some other reason.
- No easy way of logging to a database.
So i rewrote parts of the script and renamed in xenstat.pl (after vmstat). You can download xenstat.pl here. To use run "perl xenstat.pl" in domain 0. The following output will be generated, with a new statistic generated every 5 seconds:
```
cpus=2
     54_garuda_0  0.49% cpu usage  3034.56 sec over 3.61 days
    59_gyrfalcon  3.65% cpu usage  5032.13 sec over 0.80 days
        Domain-0  1.56% cpu usage  9746.05 sec over 3.61 days

2009-09-29 10:38:12 39  1 37 23
2009-09-29 10:38:17 80  0  7 13
2009-09-29 10:38:22 54  0  4 42
2009-09-29 10:38:28 25  1  3 71
```
In the above output, the first few lines summarise the CPUs and running domains. Then we have the statistics generated every 5 seconds:
```
 DATE       TIME       GARUDA   GYRFALCON DOM0  IDLE
                       CPU%     CPU%      CPU%  CPU%

2009-09-29  10:38:12    39       1         37    23
```
You can also define the interval to poll (in seconds), and the number of samples just like vmstat:
```
[root@server ~]# perl xenstat.pl 3 2
cpus=2
     54_garuda_0  0.49% cpu usage  3064.51 sec over 3.61 days
    59_gyrfalcon  3.63% cpu usage  5034.60 sec over 0.80 days
        Domain-0  1.57% cpu usage  9775.78 sec over 3.61 days

2009-09-29 10:42:26  0  0  4 96
2009-09-29 10:42:29  0  2  4 94
[root@server ~]#
```
To log the CPU utilisation, I didn't want to install a database client in Dom-0. So I added another parameter, a URL to a web server to call with the CPU info as GET parameters. I assume wget is installed in your Dom-0.
```
[root@server ~]# perl xenstat.pl 10 1  [192.168.0.1] cpus=2
     54_garuda_0  0.49% cpu usage  3065.81 sec over 3.62 days
    59_gyrfalcon  3.62% cpu usage  5039.03 sec over 0.80 days
        Domain-0  1.57% cpu usage  9782.15 sec over 3.62 days


--10:46:42--  [192.168.0.1] Connecting to 192.168.0.1:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 498 [text/html]
Saving to: `STDOUT'

100%[=====================================================================================>] 498         --.-K/s   in 0s

10:46:42 (67.8 MB/s) - `-' saved [498/498]

2009-09-29 10:46:42  0  2  2 96
```
This will accumulate statistics for 10 seconds then send it to the above url. This allows you to log the data using a REST-ful web service.
I hope this is useful for anyone using Xen.
Download xenstat.pl.
The older script written by Tom Brown.
PInetd2: new website, and release coming soon

Posted: September 28th, 2009, 8:57pm MDT by Mark Karpeles

If you never heared about PInetd, it probably means you never tried to search on google how to make a DNS server in PHP, for example.

PInetd is a generic framework allowing to run a wide range of daemons, mostly answering on TCP or UDP ports.

The main goal is to make generic protocol interfaces that can easily be overloaded to implement new features, new auth mechanism, etc… For example the FTP daemon is extended as FTPd_SQL for SQL auth.

The pinetd2 project is under development since October 4th 2007 (will be 2 years old soon), and has reached an appreciable maturity level. Most bugs were cleared and right now the system is running well. Some expected features (http admin interface, transports, etc) are not completed yet, but should appear within the next weeks, before the first official release with version 2.0.0.

PInetd includes framework tools to easily make a daemon listening on a TCP or UDP port, and also include some pre-made modules: FTP, [HTTP,] Mails (pop/smtp), DNS, NetBatch…

While official documentation is still mostly missing, previous posts here explain how to configure a DNS daemon, and the wiki contains basic documentation.

The official PInetd website is now open, and it is possible to subscribe to news feed to receive updates either by RSS or by mail.
Manipulating Images with PHP and GraphicsMagick

Posted: September 28th, 2009, 2:37pm MDT by Zend Developer Zone

Like most developers, I've known for a while that PHP comes with GD support for basic image generation and processing tasks, and I've even used it on occasion to dynamically create images. However, what I didn't know was that, hidden in PECL, is an extension to the GraphicsMagick library, which allows for all kinds of sophisticated image operations and effects. In this article, I'll introduce you to ext/gmagick, showing you some of the cool things it can do for you (and your images).
Starting Codeworks 2009

Posted: September 28th, 2009, 9:59am MDT by Andrei Zmievski

It seems that a short time ago, at the php|tek in Chicago, the Code Works conference was just a glimmer in the eye of Marco Tabini and his associates. And today I am in Atlanta, starting off the east coast leg of the conference along with a few of my friends and colleagues. The first part made stops in San Francisco (where I served as a social director since it’s my home town), Los Angeles and Dallas and it sounds like everyone had a great time.

After Atlanta we go onto Miami, which I am only familiar with through Dexter; Washington D.C., where I hope to take in a couple of sights, since I’ve never been; and New York, a city that I always love to visit.

My talks in this conference will cover VIM, regular expressions, and distributed systems with PHP, including memcache, mogilefs, and Gearman. There are many good talks on the schedule, so consider signing up and joining speakers and other attendees for what is bound to be an excellent event.
Solar 1.0.0alpha5 Released

Posted: September 28th, 2009, 8:56am MDT by Paul M. Jones

Solar 1.0.0alpha5 has been released, with a few bugfixes and one change. The change notes are below. Also of note, I have created separate "alpha" and "beta" branches, so we can continue bugfix releases on the alpha side while not having to release new beta features. Solar_Form [FIX] Form attributes for id, name, and class [...]
Buy My Old MacBook Pro!

Posted: September 28th, 2009, 7:09am MDT by Stuart Herbert

It has been my ever-faithful companion for the last three years, but now sadly the time has come to part ways with my old MacBook Pro. The only reason I’m selling is that I need longer battery life on occasion. The machine works fine, and I’ve just fitted it with a 500GB HDD (taken from my new MBP; sorry, but I’m keeping my SSD ). The outer casing’s finish is worn in one spot; not bad considering this machine has been with me all day every day for the past three years.

Full details are in the listing on eBay.

Share This
Still Spaces Left On My PHP Course In October

Posted: September 28th, 2009, 6:59am MDT by Stuart Herbert

Are you going to PHPNW09? Are you interested in my two day course on how to organise a team of PHP developers? Do you still want to go, but missed the early bird tickets?

Then keep an eye on your inbox … there’ll be an email from the PHPNW09 organisers in the next day or so including a discount code you can use to buy tickets for my course at a nice reduction.

And if you’re not yet convinced that you’d benefit from the training I’m offering, I’ve put together some reasons why this is important, and what benefits you’ll get from the course.

Share This
Bad code is good for you?

Posted: September 28th, 2009, 6:08am MDT by PHP in Action » PHP

Image by Balakov via Flickr
In The importance of bad code (or, WordPress and why I am a psychic), Marco Tabini proposes the idea that we need bad code. Or at least that we should be tolerant of bad code in open source projects because that invites participants that might otherwise not contribute.

This is an interesting idea that struck me as novel. But after thinking more about it, I believe it’s not a radical departure from what we’re all implicitly accepting, no matter how fanatical we might be about clean code.

Luke Welling’s comment to the blog post is particularly enlightening and worth quoting in full:

I’d argue that bad code is often a sign and a side effect of a thriving, welcoming user community around a project.

The OSS projects with good code tend to have a relatively small group of committers doing nearly all the work. There is a big learning curve to
working within the project’s (probably unwritten) architectural guidelines, and a big reputation curve that a new person has to climb
to get their patches accepted.

Bad code is often a sign of welcoming new contributors, taking patches that do something useful even if the approach is ugly.

We all know the problems bad code brings, but I would argue that some projects are not just successful in spite of bad code, but successful because they allow bad code.

I commented:

If we’re looking for the optimal strategy (which is likely to depend a lot on the specific project), the question may be what parts of the code need to be held to high quality standards, and what parts don’t require such strictness. And how to separate the two. Security is one of the key issues, since bugs can hide in bad code, and some of those will be security bugs.

Perhaps even more important is the question of whether and how to keep a clean separation between good and bad code. Bad code becomes a problem to me mainly when I need to maintain bad code written by others. Not that I dislike it so much; I sometimes enjoy cleaning up messes, but it slows me down. But if the person who wrote it is maintaining it, it doesn’t affect me much. So a clean separation would be helpful.

That also makes the whole issue clearer to me. Most of us use operating systems, library software and applications that aren’t necessarily up to our coding standards. Having lower code quality in parts of a project is not much different in principle. In fact, it may be less of a problem in some cases. When you a program library that has code of poor quality, the good code is dependent on that bad code. If you are programming the core of an open-source project and someone else is adding bad code in the form of an extension, the bad code is dependent on the good code, making it even less likely that the bad code can affect the good code.

In Domain-Driven Design, there is a pattern called Anti-Corruption Layer which can be helpful in preventing the bad code from having an undue influence on the structure of the good code. It’s worth thinking about, especially when the bad code has an illogical and confusing API.
<script src="http://static.zemanta.com/readside/loader.js" type="text/javascript">
Fine-grained SVN commit emails made easy

Posted: September 28th, 2009, 3:47am MDT by Liip

The idea behind sending emails on every svn commit is basically to help developers review their peer's code, which improves both awareness of the global codebase and overall code quality since errors might be picked up and go or bad coding practices can be identified and discussed between the developers.

While we have had svn post-commit hooks set up for a while at Liip for some of our bigger projects, the case of smaller ones that occupy very small teams remained problematic. The main issue being that configuring the classic post-commit hooks requires intervention on the svn server, to which not everybody has access, and since small projects might change often this can be annoying both for the sysadmins and for the developers that have to depend on someone every time they want a new svn directory to be watched.

The idea we came up with is to use svn properties as the configuration for the post-commit hook, so that anyone with commit access can set it up, and it can easily be applied to any number of directories.

The script looks up through the parent directories of every modified/added files in a commit, with a svn propget liip:review call, and once one is found, the value of the property is used as the email "To:" address(es). This means you can easily have an entire project being watched by someone, but some particular sub-directory of it will only be watched by some other persons, for example if you want to extract the xsl commits out of a php okapi project you would just add another liip:review property on the themes directory.

It is fully configurable if you want to try it for yourself, you basically need to give it the svn server url and the property to check for, then some other extras are available. To allow easy filtering in mail clients the mails sent contain a X-SVN-Commit-Mail header with the value being the name of the repository. Also the subject contains the committer name, revision and watched-paths affected.

You can get the script off of our public svn repository at [https:]] - the dispatch-emails.php script uses the svn binary and the dispatch-emails-ext.php uses pecl's svn extension for php if you prefer.
Code Works 2009

Posted: September 27th, 2009, 11:25pm MDT by Sean Coates

Tomorrow morning (in a few short hours, but I can never sleep the night before a trip), I will be flying YUL->ATL for the first city of the second leg of Code Works 2009.
I'm really looking forward to this adventure, and the first leg sounded like it was a great time.
We'll be traveling from Atlanta to Miami to the D.C. area and ending up in New York before I head home to Montreal in 8 days.
I'll be speaking on using tokens as a better solution to problems often solved with regex and using Firebug and Selenium to save some sanity.
If you can make it out, it's a great chance at a great price to get a crash course on topics that might not yet grace your developer arsenal. Hope to see you there.
Configuring PHP: Essential INI Settings

Posted: September 27th, 2009, 11:00pm MDT by Brandon Savage

When setting up a web server with PHP, there are a number of settings that are critical to consider. PHP 5.3 contains both a development INI file and a production INI file; however, users of older PHP releases (or those who don’t have direct control over their INI files) will want to pay attention and make sure that certain settings are configured.

These settings are the settings that I use whenever I configure a PHP server.

register_globals = Off A holdover from ancient PHP versions, this setting is by default turned off and should remain that way. Even though it is disabled by default, many hosts enable it to continue supporting legacy code; in your own code, I recommend you set it to off. You can turn it off on a directory basis using htaccess files.

magic_quotes_gpc = Off This is another old holdover from PHP, and is slated for removal in PHP 6, along with register_globals. This automatically adds slashes to all GET, POST and COOKIE data, meaning that a posted string of “This is my code’s string” gets converted to “This is my code\’s string”. magic_quotes_gpc offers NO security; you should turn it off. It can be turned off per directory.

error_reporting = E_ALL | E_STRICT This is the strictest error setting you can insist on from PHP. Some people will disagree with the E_STRICT statement; I think that it’s important that our code conform to high code standards, and that means having E_STRICT turned on. This should be done even on production, because you want to know about errors you’re getting from your code, even if you didn’t see them during testing.

display_errors = Off Even though we want to have PHP raise errors, we don’t want them displayed to the end user! Turn display_errors to off and log the errors instead. You can configure the log path in each directory, and you should make use of this feature. Displaying errors to the end user is a security vulnerability, because it allows them to determine the operating system and file structure of your application.

session.gc_maxlifetime = 28800 This setting is how long a session is valid on your system. The default length of time is a paltry 1140 seconds, or 24 minutes. That means that someone reading a long article behind a login portal might get logged out after they’re finished. The setting I use is 8 hours, which is enough time for most users. You can also use four hours (14,400 seconds).

short_open_tag = 0 This is on by default, but using short tags (<?) is bad form. Turn it off and don’t utilize it. (Edit) There are two reasons for this. First, and the more rare reason, is that it could create problems with XML parsing. If you ever have the need to embed PHP in XML (as I did once), you may run into this. This is rare, but possibe. Second, and more common, is that if you ever change hosts, or start using a host that configures PHP for you, they may disable the short tags by default. This could leave you scrambling for a fix for your code. Changing 20,000 <? into <?php can take a long time (I’ve done it; it can be a pain).

upload_max_filesize = 10M & post_max_size = 11M If you do anything with file uploads, you’ll find that the default 2 MB is woefully inadequate. I set mine to at least 10 MB, to ensure that most files I want are uploaded. You’ll also want to up the post_max_size due to the fact that it is set to a default of 8 MB, which will cause your file upload to break.

How to Set PHP Directives In htaccess Files
Finally, a discussion of how to set these values: if you make use of a shared host, you won’t be able to get direct access to the php.ini file. There are two different htaccess directives you need to be aware of: php_flag and php_value. The use of php_flag is reserved for boolean values, like register_globals and magic_quotes_gpc. You use php_value for things that are not boolean, like error_reporting and error_log.

For example, the syntax for turning off register_globals is as follows:
php_flag register_globals Off
The syntax to set the error log file path is as follows:
php_value error_log /var/www/logs/php_errors.log
This blog entry implements The Beginner Pattern.
How I Used Hpricot and Mechanize in GeeQE

Posted: September 27th, 2009, 6:50pm MDT by IONCANNON

While building GeeQE I wanted to enhance the CC dump of Stack Overflow's data. The main reason I wanted to do this was to capture Gravatar hashes and user badges. To do this I decided to continue using Ruby as I did with the XML loading (see my previous post on XML parsing with Ruby). The easy choice was of course Hpricot to parse the html from the users page and Mechanize to move from one page to the next.

The first thing I wanted to make sure to do was to scrape this data as efficiently as possible. That is why I use the users page instead of going over every single user's profile page. This approach is not optimal since the users pages most likely update as the script moves through them so users could be missed but I'm not looking for 100% here so that limitation was acceptable.

To run the user profile script that is described here you will first need to load the database schema and then load the CC data dump with the XML loader script.

Two good sources of information about using Hpricot can be found in the Hpricot showcase and the Hpricot challenge wiki pages.

The only tricky thing that I needed to do with Hpricot was associated with parsing badge counts since the outer spans have a title with the name of the badge type in them:
<div class="user-details">
<a href="http://planet-php.net/users/256/example-user" >Example User</a><br>
<span class="reputation-score" title="reputation score">22k</span>
<span title="8 gold badges"><span class="badge1">●</span><span class="badgecount">8</span></span>
<span title="5 silver badges"><span class="badge2"&gt
Truncated by Planet PHP, read more at the original (another 5381 bytes)
Optimistic locking

Posted: September 27th, 2009, 4:15pm MDT by Lukas Smith
I am currently touring the US as part of the CodeWorks 09 conferences, where I am holding a 3 hours tutorial on database driven PHP development. So far my sessions as consistently me less attended than the talks on testing, OO and security that are running as well. So it goes. I guess the plus side for the attendees is that I can spend more time addressing their personal needs. My tutorial essentially is based on all my previous talks on database for which I have updated all the relevant slide sets. I have also added an introduction to PDO to get things started. Since all of that will never fit into 3 hours, I let the audience pick which talks they want to hear. Unfortunately so far the Doctrine ORM talk hasn't been picked, but I am getting better and better at holding the talk about the telephone directory application and I think the work I put into making this talk very much code based is really playing off. However the slide that seems to get the most "aha, that is really cool!" is the slide about optimistic locking.

Many of our web applications require data entry forms and often times they need to handle concurrent changes. Imagine for example an address database. Multiple admins are maintaining the data and corrections and changes can happen in parallel. So if someone opens up a record, but gets side tracked, how do you prevent that person from overwritten someone else's changes when they come back after a while? One approach would be to lock the record when the edit form is opened. Of course you cannot keep that lock until forever. So the problem is not really solved at all. Worse yet, you prevent people from working concurrently together. This approach is called pessimistic locking, since you are expecting concurrent access to happen and therefore you lock things explicitly.

A much better approach in many situations is to be optimistic. Instead of locking the record when you are editing the form you simply store the time of the last change (or some counter that ensures that you can easily generate unique values that will never repeat) in your edit form. This way you can check if the record has been changed between opening and submitting the data record, enabling your application to handle this case gracefully. Like your app can present a screen showing the new current values in the database as well as those that were submitted along with some tools to merge the records.

So here is how it plays out:

Stpe one the record is created, note the "cntr" column which in this case is filled with the current unix timestamp
```
<?php
// id = 23, unix_t() = 1179145598 = $_SERVER['REQUEST_TIME']
$dbh->exec("INSERT INTO addr (id, cntr, street, city) VALUES (nextval(addr)), unix_t(), Foo Street, Bar Town)");
?>
```
In the next step any number of people are currently opening the edit form for this record. Note that we fetch the data of the record, the id and also the cntr column. The id and cntr are stored in hidden form fields:
```
<?php
$dbh->query("SELECT id, cntr, street, city FROM addr");
?>
```
Now when the first users submits the page we update the data in the database as well as the cntr column. Also note that in the WHERE statement we filter by both the id and the cntr:
```
<?php
if ($dbh->exec("UPDATE addr SET street = Foo Ave, cntr = unix_t() WHERE id = 23 AND cntr = 1179145598") {
  // record updated
} else {
  // there was a concurrent data change
 // present screen with the current and old data
  $dbh->"/>
```
Truncated by Planet PHP, read more at the original (another 522 bytes)
CodeWorks Days 5 & 6

Posted: September 27th, 2009, 1:13pm MDT by Ben Ramsey

Yesterday, the CodeWorks B-Team (the session day team, a.k.a. Team Awesome) ran into a bit of a travel snafu that actually worked out better for us. On the way to the airport in Los Angeles, we got stuck in traffic caused by an overturned cement mixer truck. And by overturned, I literally mean the cement mixer was lying flat on its back across the barrier separating the north bound from the south bound lanes. I’m not sure how it was even possible, but there it was. Derick took some video of the accident that he may or may not post later.

The traffic caused our team to be late to the airport, missing our flight. However, we were able to quickly book standby tickets for the following flight, giving us extra time at the airport to eat, placing us on a plane that had WiFi access (our original flight did not), and giving many of us exit row seats. So, it all worked out in the end.

The evening was short, due to our late arrival, but we still made it out to La Hacienda Ranch, apparently the home of the original frozen margarita. A highlight of the evening was being able to meet some of the gang from Dallas PHP, including Tim Stiles, whom I’ve conversed with online but have never met. Afterwards, a few of us ventured into Fort Worth to have a few beers at The Flying Saucer. Special thanks to Josh Holmes of Microsoft for driving us around.

As an aside, we—“we” being the speakers and community leaders attending CodeWorks—have been making lots of new friends with the Microsoft developer evangelists who have been in attendance. It seems that Microsoft has a new breed or new generation of dev evangelists who are genuinely interested in the PHP community, listening to us, and hanging out and having fun with us. For me, it’s a welcome improvement, and I’m not saying this as a surprise change I’ve only observed this week; it’s something I’ve been seeing over the last few years.

There have been a lot of great talks in Dallas. In addition to the set of CodeWorks touring speakers, the local speakers from Dallas PHP have provided some excellent presentations. I was able to enjoy Chris Cornutt’s “B.S.T, Easy as 1-2-3” presentation, and now I’m sitting in Vance Lucas’s “Object Oriented Apologetics.”

The venue in Dallas is also excellent. We’re staying at the American Airlines Training & Conference Center, and while it’s not the fanciest of hotels, I think it has been the best hotel experience we’ve had, with some of the best food and best WiFi we have seen yet. But we’re not even half-way through the tour, so there is plenty of opportunity for this to change and for me to be wowed even more.

I’m heading home this evening. My home is Atlanta, and Atlanta is the next stop on our tour, so I’ve scheduled a little family time during the tour, but I’ll be joining the CodeWorks crew each day, tomorrow for the Atlanta PHP Meet the Speakers Happy Hour and on Tuesday for my presentation.

I hope to see you in Atlanta!
Fall conference schedule

Posted: September 27th, 2009, 9:58am MDT by Henri Bergius
After a brief summer motorcycling break the fall is shaping up to be quite full with conferences. Here is the current list:
- September 30th - October 1st: OpenMind and MindTrek in Tampere, Finland
  I'll give a talk about the Midgard project and how our company has evolved together with it. In addition Linux-tekijä awards, where I was in the awards committee, will be announced
- October 9th - 11th: Maemo Summit in Amsterdam, the Netherlands
  While I'm not giving a talk in the event it will be great to meet the rest of the maemo.org team, and the community around the project
- October 17th: Finhack in Forssa, Finland
  A free-form hacking event for the Finnish free software community. Expect some progress with Midgard's XMPP capabilities
- October 23rd - 25th: Midgard Gathering probably in Berlin, Germany
  Midgard users and developers get together to learn about the new capabilities of Midgard 9.09 Mjolnir and discuss the roadmap for the next release
- October 29th: The Open Web in Ede, the Netherlands
  NLUUGs conference on new web technologies where I'll be speaking both about GeoClue and the Midgard Content Repository
- November 11th - 13th: Semantic Search workshop in Rome, Italy
  Together with a general meeting of IKS Project participants
- November 13th - 15th: FSCONS in Gothenburg, Sweden
  The annual Nordic free software gathering where I'll be speaking about Midgard2
Looking forward to all the interesting discussions and ideas that will surely come up from these events. If you will be around in one of those, make sure to look me up and we can chat. The events will also be covered in my Qaiku stream.
The Mysteries Of Asynchronous Processing With PHP - Part 1: Asynchronous Benefits, Task Identification and Implementation Methods

Posted: September 27th, 2009, 8:02am MDT by Pádraic Brady

Imagine a world where clients will give up on receiving responses from your application in mere seconds, where failed emails will give rise to complaints and lost business, where there exist tasks that must be performed regularly regardless of how many requests your application receives. This is not a fantasy world, it's reality. In the real world your application must be responsive, reliable and capable of recovery from errors. These are obvious needs but all too often applications fail to realise them. Sometimes, developers even fail to realise they should even be concerned about them.

To offer an opening real-world example, I'll borrow from a recent discussion I had concerning the Pubsubhubbub Protocol. If you are unfamiliar with Pubsubhubbub (PuSH), it's a protocol which implements a publish-subscribe model where the publishers of RSS and Atom feeds can "push" updates to a group of Subscribers. The pushing is handled by an intermediary called a Hub which is pinged by the Publisher when they update a feed, and which then distributes the update to many Subscribers using a Callback URL they each have declared.

In that discussion, the original poster was having a problem. Whenever a Hub sent his Subscriber implementation an update, it seemed to do it repetitively for some mysterious reason. Eventually, the problem was identified. The Hub implements a five second timeout. If, after five seconds, the update request was not completed because the Subscriber failed to send a valid response, it was assumed to have failed. The Hub would then attempt it again, and again, until finally its configured number of retries was used up.

Why was the five second timeout being exceeded by the Subscriber? What was taking it so long in returning a response and finishing the request? You see, the Subscriber was not simply acknowledging the receipt of an update as demanded by the protocol, it was actually processing the entire update for its own use including a number of potentially expensive database operations before it completed the request. This was taking more than five seconds.

Here's the problem in a nutshell. The Subscriber was performing work that had absolutely nothing to do with returning a response to the Hub and it was having an impact on the time it took to complete the request. The Hub couldn't care less about the Subscriber's processing, it was expecting a quick confirmation that the update was received. Instead, the Subscriber was effectively making it wait while it did something completely unrelated to that response. Using Asynchronous Processing, the Subscriber should have offloaded the feed processing elsewhere leaving it free to quickly respond to the Hub.
What is Asynchronous Processing?
Asynchronous processing is a method of performing tasks outside the loop of the current request. Basically, you offload the task to another process, leaving the process serving the request free to respond quickly and without delay. Of course, not all tasks are caused by a request. Some can performed without a request trigger, like some forms of maintenance or log parsing.

Implementing asynchronous processing can take a few directions:

1. A parent process can spawn a child process to complete a task in the background allowing the parent process continue uninterrupted.
2. You could add tasks to a Job Queue (or even Message Queue) relying on a background daemon or scheduled process to perform batch processing of outstanding tasks in the queue.
3. You could simply have a scheduled standalone task without the queue, and which is performed regardless of what requests are received.

There are, I'm sure, many more variations. Most readers will recognise at least one of these (hint: cron ). Once you understand the nature of asynchronous processing you can find many uses for it in the most unlikely of places.
What Problems Does Asynchronous Processing Solve?
Our example demonstrates that resource intensive tasks can be detrimental to responsiveness, so much so that it can can become detrimental in turn to the client, whether it be a machine applying a configured timeout and being forced into retrying the same request over and over, or whether it be an actual person who has to stare at a blank page as the seconds tick by.

Resource intensive tasks are not the only ones worth applying asynchronous processing to, though they are likely the most obvious given their impact on clients. Most tasks worth offloading can be grouped into categories:

1. Tasks which are resource intensive, i.e. needing a lot of CPU cycles or memory to complete which will add to server load and delay client responses.
2. Tasks whi
Truncated by Planet PHP, read more at the original (another 8273 bytes)
The Mysteries Of Asynchronous Processing With PHP - Part 1: Asynchronous Benefits, Task Identification and Implementation Methods

Posted: September 27th, 2009, 7:32am MDT by Pádraic Brady

Imagine a world where clients will give up on receiving responses from your application in mere seconds, where failed emails will give rise to complaints and lost business, where there exist tasks that must be performed regularly regardless of how many requests your application receives. This is not a fantasy world, it's reality. In the real world your application must be responsive, reliable and capable of recovery from errors. These are obvious needs but all too often applications fail to realise them. Sometimes, developers even fail to realise they should even be concerned about them.

To offer an opening real-world example, I'll borrow from a recent discussion I had concerning the Pubsubhubbub Protocol. If you are unfamiliar with Pubsubhubbub (PuSH), it's a protocol which implements a publish-subscribe model where the publishers of RSS and Atom feeds can "push" updates to a group of Subscribers. The pushing is handled by an intermediary called a Hub which is pinged by the Publisher when they update a feed, and which then distributes the update to many Subscribers using a Callback URL they each have declared.

In that discussion, the original poster was having a problem. Whenever a Hub sent his Subscriber implementation an update, it seemed to do it repetitively for some mysterious reason. Eventually, the problem was identified. The Hub implements a five second timeout. If, after five seconds, the update request was not completed because the Subscriber failed to send a valid response, it was assumed to have failed. The Hub would then attempt it again, and again, until finally its configured number of retries was used up.

Why was the five second timeout being exceeded by the Subscriber? What was taking it so long in returning a response and finishing the request? You see, the Subscriber was not simply acknowledging the receipt of an update as demanded by the protocol, it was actually processing the entire update for its own use including a number of potentially expensive database operations before it completed the request. This was taking more than five seconds.

Here's the problem in a nutshell. The Subscriber was performing work that had absolutely nothing to do with returning a response to the Hub and it was having an impact on the time it took to complete the request. The Hub couldn't care less about the Subscriber's processing, it was expecting a quick confirmation that the update was received. Instead, the Subscriber was effectively making it wait while it did something completely unrelated to that response. Using Asynchronous Processing, the Subscriber should have offloaded the feed processing elsewhere leaving it free to quickly respond to the Hub.
What is Asynchronous Processing?
Asynchronous processing is a method of performing tasks outside the loop of the current request. Basically, you offload the task to another process, leaving the process serving the request free to respond quickly and without delay. Of course, not all tasks are caused by a request. Some can performed without a request trigger, like some forms of maintenance or log parsing.

Implementing asynchronous processing can take a few directions:

1. A parent process can spawn a child process to complete a task in the background allowing the parent process continue uninterrupted.
2. You could add tasks to a Job Queue (or even Message Queue) relying on a background daemon or scheduled process to perform batch processing of outstanding tasks in the queue.
3. You could simply have a scheduled standalone task without the queue, and which is performed regardless of what requests are received.

There are, I'm sure, many more variations. Most readers will recognise at least one of these (hint: cron ). Once you understand the nature of asynchronous processing you can find many uses for it in the most unlikely of places.
What Problems Does Asynchronous Processing Solve?
Our example demonstrates that resource intensive tasks can be detrimental to responsiveness, so much so that it can can become detrimental in turn to the client, whether it be a machine applying a configured timeout and being forced into retrying the same request over and over, or whether it be an actual person who has to stare at a blank page as the seconds tick by.

Resource intensive tasks are not the only ones worth applying asynchronous processing to, though they are likely the most obvious given their impact on clients. Most tasks worth offloading can be grouped into categories:

1. Tasks which are resource intensive, i.e. needing a lot of CPU cycles or memory to complete which will add to server load and delay client responses.
2. Tasks whi
Truncated by Planet PHP, read more at the original (another 8217 bytes)

How I PHP: multiple inheritance

Posted: September 26th, 2009, 1:38pm MDT by Arnold Daniels

Officially PHP doesn’t support multiple inheritance. There are several ways around this, without having to duplicate code.

Wrapper

The most commonly used method is to use a wrapper object.

<?php
 
abstract class FsNode
{
  public $path;
 
  public function __construct($path) {
    $this->path = $path;
  }
 
  public function rename($newname) {
    rename($this->path, $newname);
    $this->path = $newname;
  }
}
 
class File extends FsNode
{
  public function getContents() {
    return file_get_contents($this->path);
  }
}
 
class Dir extends FsNode
{
  public function scandir() {
    return scandir($this->path);
  }
}
 
class Symlink
{
  protected $node;
 
  public function __construct($node) {
    $this->node  = $node;
  }
 
  public function target($resolve=false) {
    return $resolve ? realpath($this->

Truncated by Planet PHP, read more at the original (another 20316 bytes)

Timeline of PHP quality assurance tools

Posted: September 26th, 2009, 8:58am MDT by Thomas Koch
I'll be giving a talk on PHP quality assurance tools next week at the gearconf in Düsseldorf. The event is focused on team collaboration and most of the audience will come from other languages then PHP. Since I'm not a contributor to any QA tool I'll center around the user perspective and the process of establishing these tools in a small to middle web company like YMC.
As an outline for the first part I thought to give an historical view on QA in PHP and therefor made a timeline of PHP QA milestones:
The dates as text:
- ~1997 JUnit
- 6.4.2002 PHPUnit 0.1
- 28.8.2003 PHPUnit 1.0.0-alpha1 Release
- 13.7.2004 PHP5.0.0
- 14.7.2004 release PHPUnit2
- 30.1.2006 eZ Components 1.0
- ~sept 2006 ZF uses PHPUnit (issue #374)
- 4.10.2006 first integration of Selenium in PHPUnit
- 1.7.2007 Zend Framework 1.0
- 18.11.2007 first release of PHPUnderControl
- 19.11.2007 Project Mess Detection in PHPUnit
- 6.2.2008 first release PHP_Depend
- march 2009 qualityassuranceinphpprojects.com, thePHP.cc
main sources:
Did I get all this right? Are there things I should have added?
REST aber richtig!, Vortrag@Mayflower-Würzburg

Posted: September 25th, 2009, 11:55pm MDT by ThinkPHP /dev/blog - PHP

Am kommenden Donnerstag, den 01.10.2009 findet wieder ein öffentlicher Vortrag im Mayflower Büro in Würzburg statt (Pleichertorstrasse 2, 97070 Würzburg, Straßenbahn und die Haltestelle Congress Centrum).
Beginn ist um 18:00 Uhr, Thema des Vortrags ist "REST aber richtig!".

Johannes Brunner wird die Stärken von Representational State Transfer vorstellen und aufzeigen worauf zu achten ist, wenn Web Services unter Verwendung von REST realisiert werden sollen.

Die "Donnerstags-Vorträge" werden sowohl in Würzburg als auch in München gehalten. Bei Interesse einfach das Blog beobachten, um auf dem Laufenden zu bleiben!
Wir freuen uns auf viele Teilnehmer!

Größere Kartenansicht
CodeWorks Days 3 & 4

Posted: September 25th, 2009, 5:23pm MDT by Ben Ramsey

I’m writing this from Los Angeles during the session (or conference) day of CodeWorks. The “A Team” (tutorial team) is en route to Dallas today, while the “B Team” (session team) gives their talks.

Our flight yesterday was short, but we didn’t arrive at the hotel until nearly 4pm, and then I had to leave soon after to make it to the combined OCPHP and LAPHP user group meeting. That’s definitely been a highlight of my trip, since I enjoy meeting other user group organizers and seeing how other user groups work. I was able to meet Oleg Baranovsky and Joe Devon of LAPHP and William Estrada of OCPHP. Special thanks to Rutger Hensel for letting us meet in his co-working space in Fullerton.

There was a great crowd at the OCPHP/LAPHP meeting, and I spoke on Grokking REST, while Jason Mauer, Developer Evangelist for Microsoft, spoke about Microsoft Silverlight (and touched a little bit on Windows Azure and WebsiteSpark). In all, they’ve got two great PHP user groups and if you’re in the Los Angeles or Orange County areas, you should definitely try them out.

Today was a whirlwind of a day for me, as I’ve given three talks already, and I’m writing this just just before heading back down to the conference for a Future of Web Development panel that I’ve agreed to sit on. Since there’s been no real preparation for it, it ought to be fantastic!

This is only the second stop on the tour—five more stops to go—but already it’s been a great and exciting show. Even some of the folks from the OCPHP/LAPHP meeting last night who were on the fence about attending CodeWorks decided today at the last minute to come see what it was all about, and all I have spoken with are glad they made the decision.

Tomorrow, we head to Dallas. I hope to see you there!
Outage over

Posted: September 25th, 2009, 5:20pm MDT by Official Blog of the PEAR Group/PEAR President

The core router issues at the hosting provider have been resolved. Sorry for the inconvenience. pear.php.net and the PEAR channel are now back in business.
Reviewing A Book

Posted: September 25th, 2009, 5:00pm MDT by Brandon Savage

Earlier this week, I was contacted by Packt Publishing and asked to review one of their forthcoming books. I felt honored that they asked, and I’ll be reviewing the book on my blog in the next few weeks. For those who just can’t wait to see what they’re offering, you can check out the book, PHP Team Development.

In the interests of full disclosure, I received nothing in exchange for the review, except a free copy of the book (which is necessary in order to write a review).
PEAR Website Outage

Posted: September 25th, 2009, 2:47pm MDT by Official Blog of the PEAR Group/PEAR President
The PEAR website is currently unavailable due to network issues where the server is located. The hosting provider is working to restore service.

In the meantime, the best alternative for PEAR installer usage is to point your “preferred_mirror” to one of the mirror PEAR channel servers. Use one of the commands below to choose a mirror near you:
- U.S: pear config-set preferred_mirror us.pear.php.net
- Germany: pear config-set preferred_mirror de.pear.php.net
If you are using a PEAR installer older than version 1.9.0, and the preferred_mirror settings do not work successfully for you, a manual alternative for retrieving packages is to use the “download” command and point directly to the tarball file:
- pear download [us.pear.php.net]
- pear download [de.pear.php.net]
If using this option, you must specify the package name in the correct case, while including the version number and the file type:
- PEAR-1.9.0.tgz
- Archive_Tar-1.2.3.tar
Changing MySQL storage engine for one table in your Propel/Symfony project

Posted: September 25th, 2009, 11:22am MDT by Vidyut Luther

I need one MyISAM table in my schema, I’m using Symfony 1.2 and Propel 1.3. As flexible as Symfony and it’s YAML files are, Propel currently doesn’t allow you to change the storage engine on the fly. You use the storage engine as specified in propel.ini. As discussed in the Propel FAQ .

So, the next best thing to do now is to have it so that when Symfony runs propel:insert-sql, I can piggyback my own SQL to it. Luckily, this is possible, and it’s explained here

I now have my own SQL file running at the end, where I do an ALTER TABLE. For the lazy web.

1. Create your Alter table:

ALTER TABLE `database`.`footable` ENGINE=`MyISAM`

2. Save the file in $projectdir/data/sql/piggyback.sql

3. Edit $projectdir/data/sql/sqldb.map and append the following line:

piggyback.sql=dbconnectioname (usually propel)

Save the file and run

./symfony propel:insert-sql
Changing MySQL storage engine for one table in your Propel/Symfony project

Posted: September 25th, 2009, 11:22am MDT by Vidyut Luther

I need one MyISAM table in my schema, I’m using Symfony 1.2 and Propel 1.3. As flexible as Symfony and it’s YAML files are, Propel currently doesn’t allow you to change the storage engine on the fly. You use the storage engine as specified in propel.ini. As discussed in the Propel FAQ .

So, the next best thing to do now is to have it so that when Symfony runs propel:insert-sql, I can piggyback my own SQL to it. Luckily, this is possible, and it’s explained here

I now have my own SQL file running at the end, where I do an ALTER TABLE. For the lazy web.

1. Create your Alter table:

ALTER TABLE `database`.`footable` ENGINE=`MyISAM`;

2. Save the file in $projectdir/data/sql/piggyback.sql

3. Edit $projectdir/data/sql/sqldb.map and append the following line:

piggyback.sql=dbconnectioname (usually propel)

Save the file and run

./symfony propel:insert-sql
Upcoming talks…

Posted: September 25th, 2009, 8:29am MDT by Lars Jankowfsky

After my discussion with Arno about the right way to develop software I’ve decided that it would be a good chance to meet him in person while visiting PHP Con in Barcelona. And besides that, Barcelona and the PHP Folks there is always good for a visit.

Therefore there is - once again - another chance to enjoy my talks called ‘Refactor it! A practical journey into the test-driven world’ and ‘Agile Development with PHP in Practice’ . I did run both topics already quite often but obviously there is still a need for it. If you are new to agile development or interested in refactoring your old (shitty?) sourcecode - come in and join.

And if you are interested in the topic of the discussion with Arno - feel free to contact me. I will organize a meeting with where we will discuss the whole item over a few bottles of red wine. After receiving so many comments it would be nice if we get a few more opinions together.

After Barcelona Summer is definitly gone and it’s - as every year - time for the international PHP Conference in Karlsruhe. This time Thorsten and me will run a half-day Workshop called “Unittest for Dummies” which will address unit testing beginners. If you are not already into TDD you should definitly consider to come. Furthermore there will be a session about how swoodoo managed to withstand the massive amount of requests due to (*yeah*…) the big success. I’ve titled it “caching, sharding, distributing - Scaling best practices” - so you might get an idea about the contents.

That’s it - live from the “Oktoberfest” in munich
Speaking at PHP Barcelona

Posted: September 25th, 2009, 4:19am MDT by Lorna Mitchell

I'm delighted to announce I'll be speaking at the PHP Barcelona Conference in October. This is a new speaking topic for me, although I've been working and blogging in this area for a while, with a talk entitled "Working with Web Services". Its a very technical session looking at different types of services and the tools available for working with them. We'll also delve into overviews of how these services actually work and how we can troubleshoot when things go wrong. I'm really excited about writing and delivering this talk topic, and equally excited about my first trip to Barcelona and meeting lots of new people in the PHP community in Spain. If you are going - hope to see you there, come and say hi :)
PHP self return of the slash

Posted: September 25th, 2009, 2:33am MDT by Gareth Heyes

Not posted for a while because I couldn’t think of anything interesting to say but I thought about something I found ages ago in PHP4 and it’s been long enough now. This is also quite funny because my server is vulnerable to this (that’s what I get for crappy hosting).

So what happens if you escape PHP_SELF with htmlentities($_SERVER['PHP_SELF'], ENT_QUOTES)? Safe from XSS? I hope so. Safe from everything? Well not really or at least it didn’t used to be. You see PHP does some crazy things with the URL and it’s possible to change a form target to an external URL without using any unsafe characters. Take the following example:-

Login form

This form simulates some web application login and uses PHP_SELF to output the URL because for some reason the developer doesn’t want to type “login.php” or use __FILE___. The URL is escaped from XSS but we can change the form target by simply supplying slashes e.g.

Sending Google your password So the user enters their username and password combination and thinks that they are logging on to the target application in reality you are sending the details to a evil site.

I checked PHP5 and it seemed ok but this will serve as a reminder that the slash can get you.
Why Interfaces Rock

Posted: September 24th, 2009, 11:00pm MDT by Brandon Savage
When I first learned PHP 5’s object oriented syntax and rules, I didn’t see much of a point to the interface options. I felt that I could do more by defining abstract classes and at least filling in some of the methods with some details. Lots of people in the PHP world still aren’t 100% sure the reasons that interfaces exist, or the best way to use them. However, interfaces are very cool, and anyone who does OOP in PHP should know about them.

To start, what is an interface? An interface is a collection of completely abstract methods. Interfaces do not contain any of the innerworkings of the application; instead, they serve the sole purpose in setting a structure for the objects that implement them. All of their methods must be public. Here is a sample interface:
```
<?php

interface DatabaseI
{
    public function __construct();

    public function connect();

    public function query();
}
```
That doesn’t look very interesting at all, and it’s not, until we start getting into type hinting and using instanceof in PHP 5. This is where the power of interfaces comes into play.

As a developer, I’ve often wished there was a way to know that an object – any object – had implemented certain methods. With type hinting and the instanceof operator, it is now possible to determine whether or not an object has those methods, and interfaces make this even easier. Take for example:
```
class withoutTypeHinting
{
    public function __construct($databaseO)
    {
        if(method_exists('connect') {
            $databaseO->connect();
        }
    }
}

// Now let's use typehinting from our previous example

class withTypeHinting
{
    public function __construct(DatabaseI $databaseO)
    {
        $databaseO->connect();
    }
}
```
What’s the difference there? In the first example, we’re hoping that the method exists so that we can call it. We’ll have to throw an exception or do something if the connection doesn’t actually exist. But in the second example, we’re demanding an object that has implemented the methods in DatabaseI. We know that these methods must have been implemented, because we’re getting an instantiated object. So the method must exist.

Interfaces make it much easier to predict what methods will be available, and also to ensure that subclasses still conform to some semblance of the structure you’ve defined.

Interfaces are not without their drawbacks. One huge drawback of interfaces is that you must implement them precisely as they are defined; that is, because our __construct() method contained no arguments, you must either make your __construct() argument contain no arguments or set each argument to a value (e.g. __construct($a = true, $b = false); // etc). When defining an abstract class, and abstract methods, the rules of inheritance apply, making it possible to redefine the argument list. Also, because you have not defined anything but the method signature, you have no way of forcing it to return a particular type. Finally, you may not build an interface containing protected methods; you must use an abstract class for this.

Still, interfaces rock. They allow you to enforce the type of object and the methods that must be defined, and with type hinting you can always feel confident that a method is implemented, regardless of how that interface is extended.
Speaking at POC 2009

Posted: September 24th, 2009, 2:45pm MDT by Stefan Esser

This year I will return to Power of Community in Seoul and present a session about state of the art exploitation of PHP applications and servers. Unlike my Syscan and Blackhat talk I will also demonstrate how to find unusual code execution vulnerabilities and how to tunnel attacks through web application firewalls.

Session: Shocking News in PHP Exploitation

Remote code execution vulnerabilities in modern PHP applications have become more difficult to find and exploit due to better education of developers and the wide adoption of Suhosin, web application firewalls and other PHP environment hardening. E.g. the class of remote file inclusion vulnerabilities is practically dead in modern PHP installations.

This talk will demonstrate how a well known class of PHP application vulnerabilities that is widely believed to be a DoS vulnerability only, can result in arbitrary PHP code being executed. Furthermore it will be demonstrated how attacks on PHP applications can be tunneled through web application firewalls like mod_security with ease, bypassing the whole rule engine. And last but not least we will take a look at the recently introduced protections against interruption vulnerabilities in PHP and how it is still possible to perform post exploitation tricks as presented at Syscan and Blackhat.

See you in Seoul between 5th and 6th November.

서울에서 11월 5일에서 6일에 만나요!
5 Reasons Simple Cloud is a Dark Cloud

Posted: September 24th, 2009, 2:10pm MDT by Clay Loveless

When it comes to technology, everyone thinks they want interoperability. Using SQL, JavaScript or map APIs? There's an abstraction layer for that (SQL, JavaScript, map APIs). Writing mobile applications? There's an abstraction layer for that too (PhoneGap, Appcelerator, among others).

Developing "cloud-native" applications? Soon there'll be an abstraction layer for that too. Yesterday Zend announced the Simple Cloud API, a set of PHP classes for "writing scalable and highly available applications that are still portable."

Sounds great, right? Not so much. As Chief Architect of a PHP-based "cloud-native" application that's handling hundreds of millions of requests per month, there's no way I'd consider using Simple Cloud. Here are five reasons why you shouldn't either:

1. Abstractions leak. It's never as easy as it seems, which becomes painfully obvious at the least opportune moment. Let's have a show of hands of how many people have launched a SQL-abstraction based web application, only to find later that the crazy-ass SQL your toolset generated was 100x slower than one you'd have cooked up on your own. Okay then. The Law of Leaky Abstractions drags us down when it's time to figure out what's broken.

2. The Lowest common denominator rules. Abstraction layers often talk about unifying access to technologies where the differences are insignificant. Which is funny, since the providers of those technologies introduce differences to be competitive. Do you really want your web applications to be built around the elements of cloud services that are all the same? Your competition will likely be focusing on leveraging cloud advantages to the max, which will inevitably mean taking advantage of features that a lowest common denominator API ignores.

3. The true leaders don't participate. Simple Cloud lists contributors including Microsoft, IBM, Rackspace, Nirvanix and Go Grid, and dubs these companies as "leading the cloud revolution." Note how the three published APIs all include support for an Amazon Web Services solution. Who's really leading here? Amazon is leading the cloud revolution, and has been all along. Everyone else is just playing catch-up.

We've seen a similar situation recently. Remember OpenSocial? Google, MySpace, Yahoo and a few others banded together when Facebook handed their asses to them a couple of years ago. Facebook has never participated, and continues to lead the pack in social platform application development.

Of course all the companies that are not leading want to band together for the sake of interoperability, since interoperability means a greater chance of survival. But as a developer, be careful of getting roped into these company-serving agendas--it will cost you more than it costs them, with little return on your investment.

4. Native adoption isn't hard. Have you looked at the Amazon Web Services APIs, and noticed how many of them actually use the term "Simple" in their full descriptions? SDB is short for SimpleDB, S3 is short for Simple Storage Service. Is an API simplifying these already-simple APIs really necessary? If you're looking for a reduced feature set and inability to leverage each service to the maximum, sure! Otherwise, bite the very tiny bullet and learn about each service that you need. They're not hard. Trust me.

5. Face it: You'll probably never move. Despite portability claims, you'll likely never move from one service to another willy nilly. Consider the last significant web application you built around the database of your choice. Even if you used an abstraction layer, do you really think you could just pick it up tomorrow and move to a competing database engine? Whenever this scenario is truly considered, it's a much more complicated problem than just swapping out the underlying RDBMS. An audit must be done of all code to make sure no one snuck in a workaround query that included vendor-specific features, a new backup system needs to be evaluated (odd that no one has cooked up an SQL backup abstraction layer!), performance testing need
Truncated by Planet PHP, read more at the original (another 1682 bytes)
Bughuntday: yes, you can!

Posted: September 24th, 2009, 12:07am MDT by Michelangelo van Dam

Last week Thursday the start was given to Zend Framework's Bughuntday and it turned out to be a huge success, as mentioned by Chief Architect Matthew Weier O' Phinney on Zend's DevZone website.

Over a hunderd bugs were squashed leading up to the release of Zend Framework 1.9.3.

What is Bughuntday ?
Bughuntday is actually a term to indicate that on a specific day (or days), lots of developers are focussing their attention to fix bugs, often reported by users in a bug tracking tool (like Jira, Mantis or Bugzilla).

Since lots of users have submitted issues and only a few developers have time to investigate them, extra help is always welcome to clear a backlog of reported issues.

So, each year a "Bughuntday" is scheduled to have many developers fix issues in a relative short timeframe.

You can help !
Fixing bugs for Zend Framework is a very good way to learn best coding practices or parts of the framework you're not familiar with.

Go over to the Zend Framework Issue Tracker and look for bugs that are still open.

If you already signed the Zend CLA, you're good to go. If you haven't done this, now is a good time to do so.

Get the latest revision from [framework.zend.com] , which includes the library, unit tests, external libraries and documentation.

In case of emergency
If you're stuck, or you have created a patch to fix an issue, head over to #zftalk.dev on IRC (freenode) where you can ask for help.

The Zend Framework Bughuntday is held each third Thursday and Friday of the month and each month prizes are given to the top 3 fixers.

If your company uses Zend Framework, see if you cannot make it a company thing. The quality improvement of Zend Framework will be a great benefit for your company as well.
CodeWorks Days 1 & 2

Posted: September 23rd, 2009, 2:32pm MDT by Ben Ramsey

I’m breaking a long and terrible habit of not blogging in order to share my experiences at CodeWorks over the next two weeks. As you may know, CodeWorks is a touring PHP conference that is traveling to seven cities. I’m privileged to be speaking in each of the cities.

My trip to San Francisco began on Monday, when the metro Atlanta region received up to 15 inches of rainfall in a 24-hour period. I think the average across the region was 8-10 inches, but the point is that we received a lot of water in a short amount of time on top of having already received a lot of rain over the course of the previous week. Over 200 roads were closed and interstate highways shut down. So, I made the decision to go to the airport on Monday night and spend the night there, despite the fact that my flight didn’t leave until ten the next morning. It was the right decision, since traffic the next morning was outrageous and roads were still closed, but it led to a very long day, since I did not sleep at all. Still, it allowed me to polish my slides for two very good presentations I gave today.

After a fine evening yesterday with friends at La Trappe, a Belgian Bistro and Trappist Lounge—with very good beer, I might add—I retired to sit around a fire pit at the hotel with even more friends. Keith brought along marshmallows for roasting, and Jason provided the beer. Good times were had by all.

This morning, while sleeping off the jet lag and recuperating from my lack of sleep the night before, I awoke to a call from Travis, asking if we could switch talk time slots. He wasn’t feeling well, so I agreed, and got up for the early 9am talk, but I’m glad I did. Now, my talks are over, and I’m going to spend the afternoon enjoying San Francisco. Travis, you owe me one, buddy.

Tomorrow, we head to Los Angeles, and after that, Dallas, Atlanta, Miami, DC, and New York. If you’re in any of these cities and you’re not yet signed up for CodeWorks, don’t miss a great opportunity to hear some excellent talks. Sign up today, and I’ll see you there!

FYI, for those looking for slides, I’ll post them on October 7th at the conclusion of the CodeWorks tour.
Simple Cloud API announced

Posted: September 23rd, 2009, 2:20pm MDT by Zend Developer Zone

A number of industry leaders have comes together and made an announcement. A new Simple Cloud API is being developed for PHP, that will create an easy way to interface with any number of cloud services. The current contributors to this project include Zend, Microsoft, IBM, Rackspace, Nirvanix, and GoGrid.
A PHP 'Hello World' Script Using Zend Core for i5

Posted: September 23rd, 2009, 1:07pm MDT by Zend Developer Zone

You've successfully installed the Zend Core for i5 on your System i. Now what? This tutorial helps you write your first PHP scripts on the System i. You will learn where Zend Core is located on the System i, how to make sure Zend Core is running, how to set up Zend Studio, how to write a simple 'hello world' script, and how to access a DB2 file on the System i.
iStockPhoto Logos validates Brandstack marketplace?

Posted: September 23rd, 2009, 9:11am MDT by Vidyut Luther
A new concept for iStockPhoto called iStockPhoto Logos has been announced as a direct competitor to Brandstack. Will iStockPhoto Logos fail again?

Techcrunch just announced iStockPhoto Logos? . It seems this is a great idea that was pioneered by Brandstack. The concept both sites have is very similar, in that they both sell logos, but right now, I think logo designs by Brandstack is the better choice.

Advantage of Brandstack for designers
- You can submit a logo today on Brandstack. No need to wait till January 2010 for iStockPhoto Logos
- Work with your peers, Brandstack is full of excellent designers, who have been designing logos for a long time
- You get to keep $850 from your sale, (iStockPhoto Logos takes $500 out of every $1000), while Brandstack only keeps $150
- You put a value to your work, the iStockPhoto Logo folks seem to want to manipulate the market, and decide what your logo is worth, which sounds fairly draconian.
Brandstack advantage for buyers / consultants like me
- You can buy a logo design from Brandstack today.
- You can work with the designers to tweak the designs before you buy them.
I’m really looking forward to see what happens with iStockphoto’s Logos, I’ve never met a photographer that was good at design, composing a good photo is not the same as designing a good logo.
OSSBarCamp lightning talk on PEAR: slides now online

Posted: September 23rd, 2009, 7:03am MDT by Ken Guest

I was the the OSSBarCamp event in Dublin last Saturday and gave a lightning talk on PEAR. It went well (I think). The slides for it are now online at the talks.php.net website.
I’ll write up more thoughts on the event later if I find the time
Yii

Posted: September 23rd, 2009, 6:11am MDT by Doug Hill

Yes I'm still around! I am finally able to start working on the 60 days project I announced over 9 months ago. Yii will be the first framework up in the 60 days series. I would like to be able to give you specific reasons why I chose it but it just came down to picking one. My first choice was Kohana but they are on the verge of releasing a major update so I thought I might wait a bit.

I downloaded the framework and started the Yii blog tutorial, but I'm finding that while the concepts are pretty straight forward, the tutorial leaves out some important details so you have to do a lot of back and forth with the demo code to see what is missing.

I will be back in a couple days to update the details of the project.
Interviewed by DevExp.eu

Posted: September 22nd, 2009, 11:18pm MDT by Stefan Koopmanschap

Not too long ago I got contacted by Kenneth of DevExp. He wanted to publish an interview with me on their website. It was quite fun answering the questions and the interview has now been published.
Avoiding Notices: When to Use isset() and empty()

Posted: September 22nd, 2009, 11:00pm MDT by Brandon Savage
One of the most confusing things for new programmers (and it even trips me up sometimes) is how to test for boolean conditions in code. As developers, we want to develop code that never emits notices or warnings, and PHP gets a bit antsy when we develop code that utilizes uninitialized variables. Lucky for us, PHP makes it easy to test for these variables without getting these notices.

PHP (like most languages) evaluates a logical argument left to right. For an AND condition, both conditions have to be true; PHP stops evaluating if it finds any condition untrue; that means that we can use isset() or empty() as the first parameter in an if statement, and avoid raising notices.

For those who don’t know: isset() and empty() are two language constructs in PHP. A language construct is not a function, but a special language tool (like an if-else statement or a while loop), and in this case isset() and empty() allow us to test variables for various conditions.

When To Use isset()
The construct isset() tests for whether or not a variable exists in the present scope. If the variable has been defined in the global scope, in any form (except null), this will return true. Otherwise, it will return false.

You should use isset() when you want to determine if you wish to test that variable for another condition. For example:
```
<?php

if (isset($var) && $var > 6)
{
    // do something here
}

if(isset($var) && $var === false)
{
   // Do something else here.
}

?>
```
If the variable is not set, isset() will return false. This will cause the first condition to be false, and PHP will not evaluate the second condition (which would emit an error).

When To Use empty()
The empty() construct works in a very similar fashion to isset() but has a difference: you want to use empty() when you care whether the variable has a value that would evaluate to true.

Consider the following code sample:
```
$variable = false;

if(isset($variable))
{
    echo 'This variable is set.';
}

if(!empty ($variable))
{
    echo 'This variable is not empty.';
}
```
In the first example, isset() tells us that the variable is in fact set in the current scope. But in the second test, the variable is deemed empty, because the value is false. This is an extremely useful tool, but one that can be dangerous! False is an absolutely valid value (for example, you might set configuration options to false) but you may want to execute whatever is inside an if statement even if the value is false.

Additionally, empty strings, the values “false”, null and 0 all resolve to “true” when you use empty(). This can create problems that you’ll want to avoid, for example:
```
<?php

$string = "A string to test.";

$var = strpos($string, "A string"); // Returns integer 0 as the position it was found.

if(empty($var))
{
    echo 'Not found!';
}

?>
```
This example illustrates a case where using empty() would create a problem. strpos() returns 0 if it finds the needle at the beginning of the string (position 0). However, if it does not find it at all, it returns false. However, false and 0 both evaluate to empty! This code sample would be better rewritten as follows:
```
<?php

$string = "A string to test.";

$var = strpos($string, "A string"); // Returns integer 0 as the position it was found.

if(isset($var) && $var === false)
{
    echo 'Not found!';
}

?>
```
The use of the isset() means that we know the variable exists but we don’t evaluate its value yet. The second condition evaluates whether or not the variable is actually false (three equals signs compare type as well as value).

In a nutshell, the simple rules of empty() and isset() are this: use isset() if you only care whether the variable exists in the current scope, and use empty() if you care that the value has an actual value that evaluates to not empty.

This blog entry implements The Beginner Pattern.
Zend Framework 1.9.3PL1 Released

Posted: September 22nd, 2009, 6:05pm MDT by Zend Developer Zone

The Zend Framework team is pleased to announce the immediate availability of the 1.9.3PL1 release. This release corrects a BC break found in the 1.9.3 release, and should be used in its place. You may download it from the Zend Framework site .
A case for PEAR and PHP4 (Or, why BC is important!)

Posted: September 22nd, 2009, 12:48pm MDT by till
Every once in someone likes to argue that PEAR is all fugly PHP4 code and why you should not use it, and instead go and use another framework or component library. Most of those people also say that they looked at or used PEAR x years ago and then act all surprised when someone else disagrees.

In related (BC) news, most people probably read my blog because of Zend Framework, and I remember that one of the reasons I sold my clients on Zend Framework was a supposedly backward compatibility and clean API. Well, a couple years later one knows it's not all that and since another BC break was argued today on one of the mailing lists and the project lead said I spread fud, I felt l needed to write something on the topic.

Facts first.
A small history of PEAR.
I don't know how old exactly PEAR is, but the manual is copyrighted since 2001 and none of the other current frameworks have been around eight — almost nine — years.

Because PEAR has been around much longer, we also have more older code than any of those PHP5-only frameworks. In comparison, Zend Framework's first stable was release in June, 2007, almost six years later.
Major versus minor releases.
A package' version consists of x.y.z.

The rules are as follow:
- A BC break (see below) — increment x, and set y and z to 0.
- Adding a new feature — keep x, increment y and set z to 0.
- Fixing a bug — keep x and y, but increment z.
When someone refers to a major release in PEAR's context (and a lot of other projects such as Zend Framework, Solar and ezComponents follow this), it's one with a change in x. :-)
What is backward compatibility?
Backward compatibility, or BC, describes that a component, package or library preserves compatibility with an older versions.

Because programming itself and developers tend to evolve, PEAR tries to keep BC in all minor versions, but allows you to break compatibility to an earlier version with a new major release.

The exception to the rule is that you may break BC during alpha and beta releases before the package reaches a stable 1.0.0. Once a 1.0.0 is reached, BC may not be broken — for whatever reason.
PHP4?
Because PEAR aims to provide BC all the way, BC includes the PHP version when the package was first released. Which in turn means that of course you may make the code compatible to a later PHP release, but not without breaking compatibility to the initial release.

If you followed the above, you understand the reason why for example there is a Mail_Queue and (a soon to be) Mail_Queue2, or more importantly: why the Mail_Queue release in 2009 is still compatible to PHP4. Even though PHP4 EOL'd a while ago.

The first Mail_Queue package was released in September of 2002, the 1.0.0 stable release followed in December of the same year. Because its 1.0.0 was compatible with PHP4, we keep it backwards compatible with PHP4 until we release Mail_Queue2-0.1.0.
A principal
A lot of people argue that with the official end of life of PHP4, one should break BC anyway. But here is why you should not.
- Even though we all love to use PHP5, there is still a lot of PHP4 in the enterprise. And like it or not, many of those apps use PEAR, and not your funky PHP5 framework.
- How do you keep so-called necessary and unnecessary BC breaks apart? From another point of you (which is not your own), there is always a necessary BC break to fix implement something else.
- Because there is no such thing as small or acceptable BC breaks. There are BC breaks or there are none, it's one of those things that is black and white.
BC in other frameworks
I know for a fact that ezComponents is very strict on BC. I cannot comment on Solar or Symfony, but at least in Solar's case, I'm assuming that adhere to BC as well since a some former PEAR developers are active and they also follow the PEAR Coding Standard in many respects.
Zend Framework?
A friend of mine said that if Zend Framework really kept BC, we would at 10.0.0 and not on 1.9.3.

Reasons why Zend Framework likes to break BC, even though it advertises full BC:
- No versioning per components but per framework.
- Missing peer
Truncated by Planet PHP, read more at the original (another 1429 bytes)
Announcing Zend Framework's Monthly Bug Hunt Days

Posted: September 22nd, 2009, 12:15pm MDT by Zend Developer Zone

Last Thursday and Friday, the 17th and 18th of September, Zend Framework launched its first monthly bug hunt days. The "bug hunt" is actually more of a "bug killing" or "bug squashing" event -- the intent is to reduce the number of reported issues in the tracker by either fixing them, marking them as duplicates, or invalidating them (many issues may stem from lack of understanding of the component, invalid reproduce cases, and more). To sweeten the deal, we have also made a small contest out of it: the contributor who resolves or assists in resolving the most issues during each month's event receives a Zend Framework t-shirt.
CodeWorks 2009 Begins

Posted: September 22nd, 2009, 11:08am MDT by Matthew Weier O'Phinney

Today is the kickoff for CodeWorks 2009, a remarkable PHP road show hitting seven cities in 14 days. While I'm not joining the tour until Atlanta, I'm proud to be joining up at that stop and presenting a Zend Framework tutorial during the tour.

Continue reading "CodeWorks 2009 Begins"
Zend Framework 1.9.3 Released

Posted: September 22nd, 2009, 8:46am MDT by Zend Developer Zone

The Zend Framework team is pleased to announce the immediate availability of the 1.9.3 release. This release is the third maintenance release in the 1.9 series. Almost 100 (!) issues have been resolved for this release, covering more than 40(!) different components. You may download it from the Zend Framework site .
converting standard wordpress into a SQLite powered multi user blogging platform

Posted: September 22nd, 2009, 2:43am MDT by Hasin Hayder
ShishKabab PHP IDE

Posted: September 21st, 2009, 1:08pm MDT by PHP Classes

ShishKabab PHP IDE By Vincent den Boer A new Open Source PHP IDE, the ShishKabab PHP IDE, was released recently.

This article explains what it is, why it was developed, in what direction it is heading, and most importantly, how you can get it.
Solar 1.0.0-alpha4 Released

Posted: September 21st, 2009, 8:26am MDT by Paul M. Jones

So much for the “last alpha release” of the Solar Framework for PHP 5. ;-) The alpha4 release corrects a dozen small bugs so that users don’t have to wait for the beta in about 7 weeks. (Cross-posted from the Solar blog.) The change notes are as follows: Solar_Cli_MakeVendor [FIX] Mismatched ol/ul tags are now matched properly as ul. [...]
PHP enters top 3 of most popular programming languages

Posted: September 21st, 2009, 3:45am MDT by Ibuildings Blog

The company TIOBE, founded in 2000, is involved heavily with Software Quality. They call themselves 'the coding standards company' and deliver tools to assess the quality of software by checking coding standards, among other things. Unfortunately, despite the fact that their website is written in PHP, they do not support PHP yet with their tools (at least as far as I can tell from their website), but they have one activity that is of interest to us in the PHP ecosystem: they collect statistics on the popularity of programming languages and have been doing this for a few years now.

In their latest analysis PHP has entered the top 3 of most popular programming languages, and that is something that both makes us proud and provides further proof that PHP is still growing and here to stay.

Continue reading "PHP enters top 3 of most popular programming languages"
Comet Architektur (server push) Vortrag@Mayflower-Würzburg

Posted: September 21st, 2009, 2:38am MDT by ThinkPHP /dev/blog - PHP

Am kommenden Donnerstag, den 24.09.2009 findet wieder ein öffentlicher Vortrag im Mayflower Büro in Würzburg statt (Pleichertorstrasse 2, 97070 Würzburg, Straßenbahn und die Haltestelle Congress Centrum).
Beginn ist um 18:00 Uhr, Thema des Vortrags ist "Comet Architektur (server push)".

Martin Ruprecht wird, neben dem Aufbau und Nutzen, auch an einem Beispiel zeigen, wie Daten ohne Anfrage des Clients vom Server gesendet werden können.

Die "Donnerstags-Vorträge" werden sowohl in Würzburg als auch in München gehalten. Bei Interesse einfach das Blog beobachten, um auf dem Laufenden zu bleiben!
Wir freuen uns auf viele Teilnehmer!

Größere Kartenansicht
PEAR state of play, why move to PEAR2

Posted: September 21st, 2009, 12:16am MDT by Alan Knowles

Just before I saw Brendan's post about PHP4 compatibility in PEAR, I had been getting a few queries about making a couple of my PEAR packages more 'PHP5' compatible or PEAR2 ready.

From my perspective, pretty much all of the packages I maintain (As far as I know) are PHP5 'compatible'. however they may emit E_STRICT errors.

This brings up the interesting question, which I guess all the current maintainers, users and contributors have come across, how much value is added to the existing packages by adding that level of support.

From an 'ideal world' / 'perfect coding' perspective, they would benefit from this changes. but as somebody who earns an income by delivering projects as quickly and efficiently as possible, the return on investment for making those changes is very tiny, if not negative.

Since the packages generally just work, making the changes required, would not really change that 'just work' situation, and as Jamie Zawinski famously said "How will this software get him laid?"

Two of the biggest changes I'm aware of for this 'PHP5 compatibility' issue are the 'static' method prefix and getting rid of 'var' which completely break PHP4 compatibility (and yes we still maintain PHP4 applications, and clients rarely have budget to make changes like this). Doing these changes would mean that I would have to either freeze or depreciate PHP4 support, or start maintaining dual versions. (Personally I would prefer a hook in the package builder that would do the replacement for me, so I could upload 2 package on each release).

Going forward, PEAR2 is still in a gestation period, (as PHP5.3 and namespaces support has just come out.) Resulting in any code that had targeted PHP5.3/PEAR2 aging very quickly (eg. requiring changes to handle the final changes to the namespace syntax.). This may start changing soon, however I suspect it would really take some significant effort in time to start creating PEAR2 packages for existing code (which has a rather poor return on investment) . And without a reasonable base number of packages, the attraction of submitting code to PEAR2 is lessened. A classic chicken and egg situation.

At the same time, there is no real alternative to PEAR2, pretty much all other 'framework' solutions have been built around the assumption that you have to accept a majority of the 'framework' to utilize the single packages. Which is even worse that the pains that PEAR(1) imposes on you.

All that said, if you want to send me patches to fix any big PHP5 issues in my packages please don't hesitate, I will try and make the changes.
eZ Components Open Book

Posted: September 21st, 2009, 12:08am MDT by Tobias Schlitt

Attention: This blog post is in German, due to the fact, that the book is also in German. In short: Kores and my book about eZ Components can now completely be found online, for free. Das von Kore und mir verfasste eZ Components Buch, gibt es jetzt als Open Book komplett online zu lesen.
Peer Review: You Have Not Because You Ask Not (Requests & Responses)

Posted: September 20th, 2009, 11:00pm MDT by Brandon Savage
This entry is part of an ongoing series involving the review of a code sample and it’s refactoring. For the original code sample, see here.

The topics discussed in this entry may be fairly advanced. Please feel free to ask questions, and discuss best practices.

If you’ve been following this series from the beginning, take a moment to look at the original code sample and compare it with where we are now. We’ve come a long way!

There is one last area that I want to address, and this has everything to do with object-oriented principles and code reusability. For those who are familiar with OO programming, they realize that the use of classes does not make something object oriented by nature. In this final part of the series, we’ll move one step closer to being object-oriented, by introducing the concepts of request and response objects.

At the moment, our object takes arguments like most functions do. This has some limitations. The first limitation is that the object must be aware: that is, it must have an understanding of the request it is being passed, and the response that it is getting from Twitter, as well as the response it will give back to our application. This means that in the event that something ever changes about the way that response is organized, we have to change this code, explicitly. I would like to avoid that.

The first way we will change this need to be aware is by altering the way the request comes into the object. We will do this by passing in a request object.
```
/**
* Constructor.
* @param [HTTPRequest] $http The HTTP request object.
* @param IRequest $request The request object.
* @param string $username The username of the Twitter user
* @param string $password The password of the Twitter user
* @return void
*/
public function __construct [HTTPRequest]  [http,] IRequest $request, $username, $password)
{
$this->user = $username;
$this->pass = $password;

$this->http =  [http;] $this->request = $request;
}
```
The request object will contain the message we plan to pass to the Twitter API, and could contain other information. It could potentially contain the username and password, but since the point of this object is to log in from the backend, I’m going to assume that the credentials are coming from a configuration file and not from the environment or the end user.

Why would we want to use a request object? The reason is that the API will be the same for the request object, regardless of the structure of the $_POST/$_GET/$_REQUEST superglobal arrays. Additionally, you can add filtering capabilities to your request object, and there are a number of robust features you can add (for example, automatically turning JSON into a request object for use with web services). Your object can be totally ignorant of the structure of the request, and still access it, through the settings provided in the request object.

The second thing that we want to do is apply this principle to our response. Our tweet() method returns true or false, but it returns true or false in error conditions as well as in success conditions. Additionally, there’s no ability for us to utilize the data that Twitter gives us back during a success or failure condition. This is sub-optimal.

Let’s assume that we have a response object capable of returning a response, and it can take a string, an exception, html or JSON (depending on which arguments you pass it). With a little modification, our code now looks like this:
```
/**
* A public method to post a tweet.
* @return object An object implementing IResponse.
*/
public function tweet()
{
$message = $this->request->get('message');

// Sanity checks. These are error conditions.
try {
$chars = strlen($message);
if(empty($chars) || $chars > 140)
{
throw new Exception('No message provided is not valid for tweeting due to a length violation. Max length: 140 chars. Min length: 1 char. Given length: ' . $chars);
}

if ($this->already_tweeted($message))
{
throw new Exception('This message has already been sent to Twitter');
}
} catch (Exception $e) {
$response = new ExceptionResponse($e);
return $response;
}

// STATUS UPDATE ON TWITTER
$this-> [http->setHost(] this->baseHost . "statuses/update.json?status=" . $message);
$this-> [http->setCredentials(] this->user, $this->pass);
$this-> [http->setOption(HTTPRequest::RETURN_TRANSFER,] true);
$this-> [http->setOption(HTTPRequest::POST,] true);
$TwitterResponse = $this-> [http->execute();] $rawRespo
```
Truncated by Planet PHP, read more at the original (another 6822 bytes)
PHP On Windows – presentation slides

Posted: September 19th, 2009, 1:49pm MDT by Michael Kimsal

I gave a talk today at the Raleigh Code Camp titled “PHP On Windows”. It was decently attended, given the attendee focus at a Microsoft-sponsored event. MS has been embracing PHP much more publicly over the last year or so, and I reviewed some of the steps they’ve been taking (auto-install on IIS7, recent bytecode cache from MS, etc). The slides I used were relatively sparse, as some of the presentation was simply doing some code on Windows.

I will probably expand on this talk and may give it again at some point. If you have any good resources or info about PHP on Windows, let me know.

Logging to MongoDb and accessing log collections with Zend_Tool

Posted: September 19th, 2009, 1:00pm MDT by Raphael Stolt

Influenced by a recent blog post of a colleague of mine and by being kind of broke on a Saturday night; I tinkered with the just recently discovered MongoDb and hooked it into the Zend_Log environment by creating a dedicated Zend_Log_Writer. The following post will therefore present a peek at a prototypesque implementation of this writer and show how the afterwards accumulated log entries can be accessed and filtered with a custom Zend_Tool project provider.Logging to a MongoDb databaseThe following steps assume that an instance of a MongoDb server is running and that the required PHP MongoDb module is also installed and loaded. To by-pass log entries to a MongoDb database there is a need to craft a proper Zend_Log_Writer. This can be achieved by extending the Zend_Log_Writer_Abstract class, injecting a Mongo connection instance and implementing the actual write functionality as shown in the next listing.

<?php
require_once 'Zend/Log/Writer/Abstract.php';

class Recordshelf_Log_Writer_MongoDb extends Zend_Log_Writer_Abstract
{
    private $_db;
    private $_connection;

    /**
     * @param Mongo $connection The MongoDb database connection
     * @param string $db The MongoDb database name
     * @param string $collection The collection name string the log entries 
     */
    public function __construct(Mongo $connection, $db, $collection)
    {
        $this->_connection = $connection;
        $this->_db = $this->_connection->selectDB($db)->createCollection(
            $collection);
    }
    public function setFormatter($formatter)
    {
        require_once 'Zend/Log/Exception.php';
        throw new Zend_Log_Exception(get_class() . ' does not support formatting');
    }
    public function shutdown()
    {
        $this->_db = null;
        $this->_connection->close();
    }
    protected function _write($event)
    {
        $this->_db->insert($event);
    }
}

With the MongoDb writer available and added to the library directory of the application it's now possible to utilize this new storage backend as usual with the known Zend_Log component. The Mongo connection injected into the writer is configured via Zend_Config and initialized via the Zend_Application bootstrapping facility as shown in the listings below.

application/configs/application.ini


[production]
app.name = recordshelf

....

log.mongodb.db = zf_mongo
log.mongodb.collection = recordshelf.log
log.mongodb.server = localhost
log.priority = Zend_Log::CRIT

....

application/Bootstrap.php

<?php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected $_logger;

    protected function _initConfig()
    {
        Zend_Registry::set('config', new Zend_Config($this->getOptions()));
    }

    protected function _initLogger()
    {
        $this->bootstrap(array('frontController', 'config'));
        $config = Zend_Registry::get('config');     

        $applicationName = $config->app->get('name', 'recordshelf');
        $mongoDbServer = $config->log->mongodb->get('server', '127.0.0.1');
        $mongoDbName = $config->log->mongodb->get('db', "{$applicationName}.logs");
        $mongoDbCollection = $config->log->mongodb->get('collection', 'entries');

        $logger = new Zend_Log();
        $writer = new Recordshelf_Log_Writer_MongoDb(new Mongo($mongoDbServer), 
            $mongoDbName, $mongoDbCollection);

        if ('production' === $this->getEnvironment()) {
            $priority = constant($config->log->get('priority', Zend_Log::CRIT));
            $filter = new Zend_Log_Filter_Priority($priority);

Truncated by Planet PHP, read more at the original (another 8888 bytes)

Imagick and Gmagick builds available for Windows

Posted: September 18th, 2009, 9:23pm MDT by Mikko Koppanen

The new Windows build page [valokuva.org] contains builds for both Imagick and Gmagick. All builds are done using VC9 and PHP 5.3.

ImageMagick builds are QuantumDepth 16 (default).
GraphicsMagick builds are QuantumDepth 8 (default).

Please note that these builds won’t work with the official PHP.net binaries which are compiled using VC6.

Edit: Pierre corrected me that there are official VC9 builds of PHP available at [windows.php.net]
The ZendCon Sessions Episode 26: Best Practices of PHP Development

Posted: September 18th, 2009, 1:48pm MDT by Zend Developer Zone

Presenting the latest edition of The ZendCon Sessions. The podcast that rebroadcasts sessions/talks from the last ZendCon PHP Conference. This episode of The ZendCon Sessions was recorded live at ZendCon 2008 in Santa Clara, CA and features Mike Naberezny & Matthew Weier O’Phinney giving their tutorial: “Best Practices of PHP Development”
My first PHP Unconfernce

Posted: September 18th, 2009, 8:55am MDT by till
I went to Hamburg last weekend to visit the PHP Unconference, which was probably my first conference ever. I've been to a couple barcamps and other smaller events, but anyway, this felt more like a real conference to me. That is, if I exclude ALA and the various ad:tech's I had to go to.

The reasons why I usually avoid tech conferences include foremost the price tag (working for myself, I can technically label it as an expense, but I still have to pay for it), doubts that it'll be worth it in terms of knowledge gained and probably time. I tend to catch up with people outside of conferences (when they are in Berlin :-)) and that has worked well for me.

I'm glad I set all these things aside for Hamburg (and it was all too easy). A lot of people expressed how much they liked their (often 3rd) PHP Unconference, and I can second, or third that — job really well done. Ulf Wendel took it one step further, blogged and asked, "Is perfect too boring?", because everything worked out so well. I guess I would say, "No, it's not boring", and I'm inclined to add, "Thanks, it really felt like having a weekend off, yet I still learned something and met a ton of nice people (or connected online nicknames to real faces)!".

I can definitely see why people visit the PHP Unconference each year, and I'll be one of them next year! ;-)

As I said, I had a great time, both my topics were accepted too. One was merged with another PHP performance talk which was overbooked with PHP VIPs which is why I decided to listen to Kore Nordmann's talk on CouchDB instead, and the other one ("Deployment") — I kind of overslept. And I'm sorry about that! I'll make sure to avoid party, party Hamburg next year.

Here are the slides for my Zend Framework (performance) talk, I hope you find them interesting:

The slides and speaker-notes contain...
- a small intro as of why I think it's worth while to get into the ring with it
- hints and pointers on general PHP optimization
- I detail on a couple components (e.g. things to look out for and how to overcome them)
Make sure to check the speaker notes (using this link) — I didn't put everything in there, but a lot.

(The deployment slides will be up later this weekend.)

This also reminds me to improve my presentation-fu. I need something as kickass as keynote, but for Windows (currently). If anyone has a pointer, let me know. ;-)
KOffice CLI converter getting a boost!

Posted: September 18th, 2009, 3:56am MDT by Lukas Smith

Long ago I had a project where we needed to generate Word documents. We ended up using a fake X-Server running OpenOffice and some queuing mechanism to manage the fact that each OpenOffice instance could only handle one conversion job at a time. No fun, but it worked, does not scale amazingly obviously. Back then I of course also tried the KOffice converter which is easily run with little overhead via a CLI interface. Unfortunately it wasn't really up to the job in terms of Word compatibility.

When I first heard of Apple adopting Khtml for their Safari browser, I was praying they would do the same when they replace their AppleWorks suite. Unfortunately they didn't. The good news is that Nokia seems to have adopted KOffice for their Maemo platform, which means that KOffice will come bundled on the N900 Linux smartphone. W00t! Looks like they are focusing on MS Office compatibility too, though I guess for now they focus on import and not on export. But its all very good news indeed and could make it a lot easier to solve these kinds of client needs in the future!
Eigene PHP Erweiterungen entwickeln Vortrag@Mayflower - München

Posted: September 18th, 2009, 3:38am MDT by ThinkPHP /dev/blog - PHP

Am kommenden Donnerstag, den 24.09.2009 findet wieder ein öffentlicher Vortrag im Mayflower-Büro in München statt (Mannhardtstraße 6, S-Bahn Isartor). Beginn ist um 18:00 Uhr, Thema des Vortrags ist Eigene PHP-Erweiterungen entwickeln" und wird von Johannes Schlüter gehalten.

"...Auch wenn PHP schon einen großen Funktionsumfang mitbringt, gibt es Gründe, neue PHP Erweiterungen in C zu entwickeln. So will man zum Beispiel eine bestimmte Bibliothek ansprechen oder Berechnungen beschleunigen. PHP bietet dafür eine Schnittstelle, die leider ungenügend dokumentiert ist. In diesem Vortrag werden die Grundlagen geschaffen und mit praktischen Beispielen die Einstiegshürde umschifft.
Teilnehmer mit fortgeschrittenen PHP-Kenntnissen sollten nach dem Vortrag ein grundsätzliches Verständnis über die Zusammenhänge haben. Grundlegende Kenntnisse in der Entwicklung mit C sind jedoch von Vorteil, um das vermittelte Wissen praktisch einsetzen zu können...."

Die Donnerstags-Vorträge werden sowohl in München als auch in Würzburg gehalten. Bei Interesse einfach das Blog beobachten, um auf dem Laufenden zu bleiben!

Wir freuen uns auf viele Teilnehmer!
The Slow Death of PHP 4

Posted: September 17th, 2009, 11:00pm MDT by Brandon Savage

Recently, I’ve been getting more and more into community-supplied code, since it’s generally been getting better. Namely, I’ve been exploring the PEAR offerings, and seeing what pieces I can integrate into my personal framework for development. One of these packages is the package called Log, which allows for easy logging of application events.

So imagine my surprise and sadness to learn that the package still supports PHP 4.

The truth is that there are lots and lots of hosts that are still on PHP 4. There are still lots and lots of lines of PHP code that make use of PHP4-level features (see Wordpress and Drupal for examples). My complaint is that PHP 4 has been officially unsupported for the last year now, and PHP 5 has been out for over five years. Five years! That’s a long time to wait to take advantage of new features in the language.

Sadly, developing for PHP 4 backwards compatibility is something that companies and individuals are still doing. Wordpress released a new Widget API in version 2.8 that relies on the old-style PHP 4 constructor. Apparently, for Wordpress and many other developers, wide adoption is more important than language improvements.

In the case of Log, supporting PHP 4 is a reality and a requirement imposed by PEAR. I certainly do not discount the efforts of package maintainers like Jon Parise, Jan Schneider and Chuck Hagenuch, who are bound by PEAR’s rules that prohibit the breaking of backwards compatibility. These individuals are working hard to support a package that is used by hundreds of developers, and is depended on for the proper functioning of 21 individual PEAR packages. I’ve been in the process of working through a PHP 5 version of the Log package, both for my own use and perhaps contribution to the community, because I think that having the ability to use statics, abstracts, interfaces and typehinting are important enough to merit the work.

Still, I look forward to the day when PHP 4 finally does go away forever, leaving us with a much better code base and happier developers.
Book review: Mastering phpMyAdmin 3.1

Posted: September 17th, 2009, 1:46pm MDT by Zend Developer Zone

A review of the book Mastering phpMyAdmin 3.1 for Effective MySQL Management by Marc Delisle.
Cahaya CMS 1.0 released!

Posted: September 17th, 2009, 12:11pm MDT by Zend Developer Zone

Cahaya CMS is a new content management system build on Zend framework. It is released under GPLv3 license. It offers many useful features if you are just an user, a designer or a developer. For more details, downloads and demo please visit www.cahaya-project.org
Zend Framework Monthly Bug Hunt Starts Today - C'mon, Join In!

Posted: September 17th, 2009, 5:33am MDT by Pádraic Brady

As Matthew announced during the week on the mailing lists, Zend are sponsoring a two-day Bug Hunt every month starting today. And there will be prizes for those who solve lots of issues! Here's Matthew's email:

Greetings, one and all!

I've alluded several times in the past month to having a plan for
helping manage our ever-growing bug list in the issue tracker. We're now
ready to roll out phase one of this plan, and we need *you*!

Starting this month, we will be sponsoring two bug hunt days monthly, on
the third Thursday and Friday of the month. That's this upcoming
Thursday and Friday, 17-18 September 2009.

During those days, the Zend team -- myself, Ralph, and Alex -- will be
in #zftalk.dev on Freenode for our entire work day (Ralph and myself are
in the United States, Alex is based in Russia; figure out the timezones
yourself (-: ). We will be triaging bugs ourselves, but, more
importantly, we will be there to help facilitate *you*, our contributors
and users, in resolving issue reports.

As an incentive, each month, we will ship a Zend Framework t-shirt to
the individual that assists in the most issue resolutions during the bug
hunt days, whether via patches or direct commits. Quarterly, we will
evaluate overall contributions, including documentation, bug fixes, and
newly contributed components, and award a developer with their choice of
a Zend Studio license or Zend Framework Certification voucher. (Caveat:
one t-shirt per person per year, and one license/voucher per person per
year, folks!)

For those interested in participating in the bug hunt days, the rules
are simple: have a signed CLA on file, and resolve issues in the
tracker.

If you have not yet signed a CLA and want to participate, you can get a
copy of the form here:

[framework.zend.com]

Sign it and return it (you can email it, fax it, or send it via post);
if you send it via post, you'll need to wait for confirmation that
we've received it before we can accept code contributions from you.

Now, when it comes to the issue tracker, you'll need to determine if the
issue:

* is simply the reporter misunderstanding or misusing code OR
* is a request for a new feature OR
* is a reproducible issue

In the first case, comment on it and indicate the correct usage, and ask
the component maintainer or somebody from Zend to review your response
and mark the issue as resolved. In the second case, please try and focus
on issue reports instead of feature requests during the bug hunt days.

That brings us to the final case, reproducible issue reports. With
these, you'll need to do the following:

* Capture the reproduce case as a unit test
* Resolve the issue in such a way as to maintain backwards
compatibility with existing usage. (In other words, don't change the
signature of a method unless the signature is what is actually
broken.)

From there, you then have two options:

* If you already have commit access, commit the test and fix to the
repository, and either resolve the issue or ask somebody from Zend to
review and resolve. Don't forget to merge your changes to the 1.9
release branch!

* If you do not have commit rights, create a patch with the unit test
and fix, and attach the patch to the issue. Ask the maintainer or
somebody from Zend to review and apply the patch.

If you need help creating the unit test or patch file, hop onto the
#zftalk.dev IRC channel and ask for help.

How should you choose issues to work on? Answer the following questions,
and you should be able to hop right in:

* What components do you have expertise in?
* What components are you interested in learning more about?
* What issues have a high number of voters or watchers?

Bug hunting should be fun, so pick components and issues you're
interested in. Ask questions on IRC if you don't understand how
something works.

So, spread the word, and come prepared this week to help make the
framework even better! I look forward to seeing you on IRC this week!

The Zend Framework has quite a large number of issue that need to be resolved/closed/marked invalid. People often have this fuzzy idea that somehow all three members of Zend's framework team will miraculously resolve them for us in between developing components, fixing the documentation, handling releases, offering support, and...lots of stuff. This idea needs to die a quick death - the Zend Framework is an open source project so the
Truncated by Planet PHP, read more at the original (another 1156 bytes)
Getting ready to rockstar

Posted: September 17th, 2009, 2:28am MDT by Stefan Priebsch

To be honest, I have always wanted to be a rockstar. Why else would I pick up my brother’s electric guitar and try to teach myself how to play when I was sixteen or seventeen? "Don Marco" has finally made it possible. On Sunday, I’ll leave for San Francisco to do a 14 days-7 cities tour [...]
PHP 5.2.11 Released!

Posted: September 16th, 2009, 4:00pm MDT by PHP: Hypertext Preprocessor

The PHP development team would like to announce the immediate availability of PHP 5.2.11. This release focuses on improving the stability of the PHP 5.2.x branch with over 75 bug fixes, some of which are security related. All users of PHP 5.2 are encouraged to upgrade to this release. Security Enhancements and Fixes in PHP 5.2.11:Fixed certificate validation inside php_openssl_apply_verification_policy. (Ryan Sleevi, Ilia)Fixed sanity check for the color index in imagecolortransparent(). (Pierre)Added missing sanity checks around exif processing. (Ilia)Fixed bug #44683 (popen crashes when an invalid mode is passed). (Pierre) Further details about the PHP 5.2.11 release can be found in the release announcement, and the full list of changes are available in the ChangeLog.
PHP Abstract Podcast Episode 46: Paul Tomlinson on Torpor

Posted: September 16th, 2009, 10:31am MDT by Zend Developer Zone

PHP Abstract has a new episode! This time I’m talking with Paul Tomlinson about Torpor , a new ORM persistence abstraction layer for PHP . He talks about the reasons behind making this new layer, and how it’s features compare to other similar solutions.
PHPUnit 3.4.0

Posted: September 16th, 2009, 9:55am MDT by Sebastian Bergmann

A year and a day has passed since the release of PHPUnit 3.3. Time to finally release PHPUnit 3.4.
Among the features introduced in this new version, the most notable are the support for test dependencies and fixture reuse as well as the possibility to run tests in separate PHP processes for increased test isolation. Please have a look at the ChangeLog for a complete list of changes.
Work on PHPUnit 3.5 has already started: the php-code-coverage project on GitHub is home to a refactoring of PHPUnit's code coverage functionality that will be one of the "hallmark features" of PHPUnit 3.5. It will also make PHPUnit's code coverage functionality available outside the scope of PHPUnit.
removing empty elements from an array, the php way :)

Posted: September 16th, 2009, 8:32am MDT by Hasin Hayder
Swift Mailer Takeover

Posted: September 16th, 2009, 7:30am MDT by Fabien Potencier

As you might have noticed if you follow me on Twitter, I'm the new project manager of Swift Mailer, a powerful mailing library for PHP.

This is a great honor for me to take over such a project. The Swift Mailer project has been initiated by Chris Corbyn some years ago. He has done a wonderful job during the years, trying to find the best way to create a top-notch emailing solution for PHP. With the release of the 4th version of Swift Mailer earlier this year, I think we now have a very solid mailing library. It is one of the most beautiful code I have had the pleasure to read. Also, the library is feature-rich, object-oriented, and very modular thanks to its plugin architecture. The good news is that Chris will still work on the project, so the takeover will be smooth.

Unfortunately, it seems that Swift Mailer has not been as widespread as it deserves to be. One of my goal is to spread the word about it, and of course, if you are looking for a good solution to send emails, try it, you won't be disappointed. It is already used by companies sending ten of thousands of emails per hour!

As a good news never comes alone, as we say in France, Swift Mailer 4 will also be supported as the default emailing solution as of symfony 1.3.

I also have lots of ideas to move the project forward. One of them is to better support the intricacies of Japanese emails. Another one is to have better documentation, and more people talking about the project.

Of course I need help. So, if you want to join a great Open-Source project, visit the Swift Mailer website today, subscribe to the mailing-list, and help us build a great PHP library!
PHP Unconference in Hamburg

Posted: September 16th, 2009, 6:49am MDT by Stefan Priebsch

Es ist immer wieder erstaunlich, was Freilwillige und Enthusiasten so alles auf die Beine stellen können. Das beginnt in Nordamerika mit der PHP Quebec, die im nächsten Jahr ConFoo heißen wird, und endet mit der PHP Unconference in Hamburg - zumindest, wenn man die Landkarte von links nach rechts und von oben nach unten liest [...]
SVN commit cooks

Posted: September 16th, 2009, 3:42am MDT by Kore Nordmann

Thomas moderated a discussion during the PHP-Unconference-Hamburg on SVN commit hooks. It showed that there is interest in my commit message parser, so that I make it available now…
SVN commit hooks

Posted: September 16th, 2009, 3:42am MDT by Kore Nordmann

Thomas moderated a discussion during the PHP-Unconference-Hamburg on SVN commit hooks. It showed that there is interest in my commit message parser, so that I make it available now…
PHP Extension Development: Vortrag@Mayflower-Würzburg

Posted: September 16th, 2009, 12:54am MDT by ThinkPHP /dev/blog - PHP

Am kommenden Donnerstag, den 17.09.2009 findet wieder ein öffentlicher Vortrag im Mayflower Büro in Würzburg statt (Pleichertorstrasse 2, 97070 Würzburg, Straßenbahn Congress Centrum).
Beginn ist um 18:00 Uhr, Thema des Vortrags ist PHP Extension Development.

Johannes Schlüter zeigt, was beim Entwickeln von PHP Extensions alles zu beachten ist und wie man dabei am geschicktesten an die Sache ran geht.

Die "Donnerstags-Vorträge" werden sowohl in Würzburg als auch in München gehalten. Bei Interesse einfach das Blog beobachten, um auf dem Laufenden zu bleiben!
Wir freuen uns auf viele Teilnehmer!

Größere Kartenansicht
Custom Apps: Some Strategies For Easy Configuration Files

Posted: September 15th, 2009, 11:00pm MDT by Brandon Savage
One of the decisions that has to be made each time an application is written for distribution is how best to set up the configuration files. There are a number of different approaches taken to this: some opt to use the define() function and define constants, while others use large arrays. The purpose of this post is to discuss a couple of configuration options that sometimes are overlooked by developers (including myself until last year).

Class Constants
One of the biggest struggles in OOP programming is how to go about setting up the default values and configuration values. For example, if you have a database class, how do you define the connection parameters?

One solution that I like is to use class constants. Class constants are just like constants you define with the define() construct; however, they adhere to more object-oriented patterns, and help keep you from having to draw the constants from outside the class. There are some drawbacks, though: while constants can be defined at runtime with a variable, you have to define class constants in the code base itself. That is, you have to use a string or an outside constant to set the constant’s value.

Let’s take a look at how this works:

Example 1: A typical database constructor
```
// Assuming a MySQL connection and
// not addressing database interoperability...
public function __construct($username = 'user', $password = 'pass', $host = 'host', $database = 'mydb')
{
	$dsn = 'mysql:host=' . $host . ';dbname=' . $database;

	try {
		$this->dbh = new PDO($dsn, $username, $password);
	}
	catch (PDOException $e) {
		throw new DBException('Unable to connect to PDO: ' . $e->getMessage);
	}
}
```
Example 2: A database constructor using constants
```
// Assuming a MySQL connection and
// not addressing database interoperability...
public function __construct($username = Config::DBUSER, $password = Config::DBPASS, $host = Config::DBHOST, $database = Config::DATABASE)
{
	$dsn = 'mysql:host=' . $host . ';dbname=' . $database;

	try {
		$this->dbh = new PDO($dsn, $username, $password);
	}
	catch (PDOException $e) {
		throw new DBException('Unable to connect to PDO: ' . $e->getMessage);
	}
}
```
It might look initially as though I’ve simply replaced the default arguments with another set of default arguments. But look again. I’ve done more than that. While the arguments would likely be stored in the Config class and be identical to the ones we were giving the constructor before, by placing all the arguments in a class (and presume that we place a large number of other arguments in that class as well regarding our configuration), we’ve simplified distribution. Imagine if you distributed your code to six different servers, all with different hosts. That would be insane to change the code every time!

The use of class constants also allows us to access values in another class through PHP’s object model, rather than relying on the “hacks” in PHP (like the fact that constants defined with define() are in all scopes). It also means that we don’t have to pass in the connection arguments each time we connect – unless we want to connect to a non-standard database.

This model is fairly well used by lots of projects, including Zend Framework and Propel, but often trips up first time developers of object-oriented code.

INI Files
Every professional PHP developer is familiar with the php.ini syntax, and has probably edited their php.ini file on occasion. What many developers don’t know (and I didn’t even know until DrupalCon 2009) is that PHP includes a function for parsing a configuration file in the INI style. The function is called parse_ini_file() and it parses an INI file into an array.

Example 3: Sample INI file
```
; Application configuration script.

[database]
host = localhost
database = mydb
username = user
password = password

[paths]
uploaddir = /var/www/uploads
includedir = /var/www/includes
publicdir = /var/www/public
```
By using the parse_ini_file() function, we get an array that looks like this (output using print_r()):

Example 2: Parsed INI file as array in PHP
```
Array
(
    [database] => Array
        (
            [host] => local
```
Truncated by Planet PHP, read more at the original (another 2203 bytes)
Upgrading to Snow Leopard adventures

Posted: September 15th, 2009, 11:41am MDT by Evert Pot

I just got my copy of snow leopard in the mail, so I decided to upgrade my laptop. After doing a full backup, I didn't turn out to be as easy as I thought.

The installation process quickly showed a little yellow triangle, indicating I didn't have any startup disks. I quickly remembered I had a dual boot to Ubuntu, and used Refit, which is basically an alternative boot menu, to get into Linux and the likes.

So I looked up the removal instructions, but unfortunately this didn't change the situation. I then read that OS/X will restore the standard EFI loader (if that's the correct terminology), by opening the Disk Utility, and making the partition slightly smaller and bigger again. Trying this I got an odd error, namely "MediaKit reports no such partition". No dice.

So I ended up booting an Ubuntu Live CD, removing the linux ext3 and swap partitions there. After this was done, I was able to resize the main OS/X partition, which eventually fixed the problem.

If you ran into similar problems, I'm hoping there's enough keywords in here for you to find this solution :).

After all that installing Snow Leopard is a bit of an anti-climax. As advertised, not a lot changed, and I've yet to see a noticeable speed difference. The OS is using less disk-space, but 29 euro is still a high price for a glorified 'rm' statement.

I do notice small notification improvements here and there, and Address Book.app now supports CardDAV, which is nice.
How Do You Keep Trac?

Posted: September 15th, 2009, 12:54am MDT by Stuart Herbert

Stuart is running a course in Manchester in October immediately before the PHPNW09 conference on how to setup and organise your PHP developers to ensure things run smoothly for you and your customers, which will include looking at how to get the most out of Trac. Learn more about the course, or sign-up now.

When it’s just you, working on one project at a time, it’s easy enough to keep track of the work you’re doing and the work you still need to do to complete the job. Chances are you can keep it all in your head, or at least keep the discussions with your customer on something like Basecamp in your head. You know that you should be using source control and bug tracking because it is “best practice”, but it just seems like too much of an overhead to bother with when it’s just you. After all, you’re working on the customer’s server, and there’s no-one else editing the code anyway.

Some of the folks reading this blog post might be cringing at that, but I’ve lost count of the number of times I’ve come across professional PHP developers who work in exactly this way. Is it because they don’t know better? Maybe. Is it because it has worked okay for them up to now? For sure.

But eventually, there comes a point where one developer becomes a team of two … or more. Having a team means that you can go after larger projects … but it also means that you have to go after larger projects to pay the team. Larger projects mean more complicated requirements, multiple phased deliveries … and a larger, more demanding (and probably a more complicated) customer holding the pay cheque.

Running a team of PHP developers (like all management activity in all walks of life) comes down to three key things: direction, organisation, and supervision. Only now it isn’t just you and a customer, just a list that you can keep in your head. Now you need to keep track of a larger list, of multiple lists for multiple people to work on that need to be brought together in the end, and if anything slips through the cracks it’s your reputation on the line. Getting the customer to come back for repeat business just got a lot less easy to take for granted.

Trac and Subversion have been part of our community’s toolkit for many years now. Used correctly, you can get yourself and your customers well-organised, and grow your reputation when you grow your team. If you haven’t started using them yet, both are open-source, and well-backed with plenty of information freely available around the blogosphere on how to use them.

Or join me in Manchester in early October, where I’ll show you how they fit into an overall approach to running your team of PHP developers.

Share This
New Article "Using PHP with Oracle HTTP Server 11g"

Posted: September 14th, 2009, 2:13pm MDT by Christopher Jones

Our Application Server team have put together a new article on installing PHP to use with the latest version of "Oracle HTTP Server" from our Fusion Middleware suite. The article is at: [www.oracle.com]
OS/X internet sharing defaults to 192.168.2.* range.

Posted: September 14th, 2009, 12:49pm MDT by Evert Pot

I was stumped, I was trying to hook up a second computer on the internet through ethernet. Normally it's easy enough to just turn on internet sharing. It turns out OS/X always uses 192.168.2.*, which happened to be in the same subnet as the WiFi network.

OS/X provides no way to change this as far as I could tell. Thankfully I was able to change the router's settings. If you ever get into this situation and you're not able to make this change, here's a simple guide to setup internet sharing using the console.
Using Google WorldMap visualization component in your applications

Posted: September 14th, 2009, 10:31am MDT by Hasin Hayder
Autumn Plans

Posted: September 14th, 2009, 6:26am MDT by Derick Rethans

I've been missing-in-action on my own blog for some time. Moving to London does that to you. Anyway, I've not been idle in the meanwhile at all, and been working on some cool side-projects. First of all I've been adding some features to Xdebug. Xdebug is now slow reaching beta-status for the 2.1 release. New feature will include proper PHP 5.3 support, variable tracing, "scream" support and other minor features.

Besides Xdebug I've also been hacking on PHP-GTK applications for my phone. The major new thing that I have now is a PHP-GTK twitter client that works like I want it... and I even use it on my desktop instead of all the other stuff that's out there. I will soon be publishing this client in my CVS repository.

Now that the conference season is starting again I'm working on improving several talks, as well as rewriting some parts for them. The first conference that I will be speaking at, are part of "Marco's Crazy PHP Conference Tour" aka CodeWorks. I'll be giving three different talks here, one on "Debugging with Xdebug", one on PHP's DateTime support and one on "Improving your development process" where I'll be talking about Test-Driven Development and other tricks associated by running a project. As CodeWorks is a bit like a rock-star tour, I'll be keeping a video blog of it somewhere on the intertubes.
PHP Extension Development: Vortrag@Mayflower-Würzburg

Posted: September 14th, 2009, 12:00am MDT by ThinkPHP /dev/blog - PHP

Am kommenden Donnerstag, den 17.09.2009 findet wieder ein öffentlicher Vortrag im Mayflower Büro in Würzburg statt (Pleichertorstrasse 2, 97070 Würzburg, Straßenbahn Congress Centrum).
Beginn ist um 18:00 Uhr, Thema des Vortrags ist PHP Extension Development.

Johannes Schlüter zeigt, was beim Entwickeln von PHP Extensions alles zu beachten ist und wie man dabei am geschicktesten an die Sache ran geht.

Die Donnerstags-Vorträge werden sowohl in Würzburg als auch in München gehalten. Bei Interesse einfach das Blog beobachten, um auf dem Laufenden zu bleiben!
Wir freuen uns auf viele Teilnehmer!

Größere Kartenansicht
Peer Review: Testable Code And Architecture

Posted: September 13th, 2009, 11:00pm MDT by Brandon Savage
This entry is part of an ongoing series involving the review of a code sample and it’s refactoring. For the original code sample, see here.

Now that we’ve worked out the abstraction issues and the logic questions, we should take a moment to focus our attention on a few of the issues relating to the architecture and testability of the class we’ve worked out.

A couple of big architecture issues raise their heads early on. The first one is this set of code:
```
<?php
// class_Twitter.php - NPC TWITTER AUTO-FEED
error_reporting(E_ALL); 

// DO NOT RUN THIS SCRIPT STANDALONE (HAS PASSWORD)
if (count(get_included_files()) < 2) {
    header("HTTP/1.1 301 Moved Permanently"); header("Location: /"); exit;
}
```
This raises a number of architectural issues that we should address. My recommendation is that we remove this code altogether. The first line, about error reporting, really should be set at the application level, rather than the script level. As for the redirect, this is intended to prevent the script from being called directly. However, it’s a good idea to place classes like this outside the document root anyway, meaning that they would never be called directly. When including this file, there’s the potential that you’ll not have included enough files and you’ll inadvertently redirect your user. So let’s drop these lines altogether. This will improve reusability and improve the architecture.

There’s another line of code that is particularly troubling:
```
$this-> [http->setHost(] this->baseHost . "statuses/update.json?status=".urlencode(stripslashes(urldecode($message))));
```
It may not look obvious at first, but this code relies on the assumption that the magic_quotes_gpc directive is set to on.

For those who don’t know, magic_quotes_gpc automatically adds slashes to all GET, POST and COOKIE variables that come into an application. This deprecated feature represents a poor programming practice, and its use is discouraged. Though it remains on by default in PHP installations, it should be turned off altogether if at all possible. It’s slow, and potentially dangerous. Additionally, it will be removed in future versions, meaning that code relying upon magic_quotes_gpc will break in the future.

Now, oftentimes programmers don’t have direct access to the magic_quotes_gpc directive in php.ini, but it can be set on the htaccess level, if your hosting provider allows you to access PHP variables in this way.

I’m going to make the assumption that we’ve disabled magic_quotes_gpc, as is recommended by the PHP manual.

Another problem that we need to address is the fact that this object gets thrown away after it’s been used. We have the property $done, which gets set when a tweet is successful. Unless there’s a good reason for it, objects should never be designed this way. We’ll remove this code in the final draft (see below).

Moving on to testing, again we have to ask ourselves about abstraction. Where testing is concerned, it would be very easy to abstract the testing out of this object. Making use of things like the HTTP_Request2_Adapter_Mock class will help us to “test” the Twitter interface without actually posting a tweet. Unit testing software like PHPUnit will give us reports on code coverage.

If we opt to leave the test code in the object itself, it should be abstracted into its own method. But I don’t recommend this course at all, because testing should be conducted at the application level. Moving testing out of the class also allows us to remove references to the $done property, and remove the $you property as well as the test() method, the $test property, and a large bit of code from the tweet() method. All of this code will then not be loaded on each request of our class. Not a bad improvement.

Something else that we’ll do in order to improve testability is we will inject (rather than create) the [HTTPRequest] object into the class. This allows us to both inject an object that is a mock object, and it also allows us greater control over the environment when we do our testing.

It was pointed out by the blog PHP In Action that one of the things that we should have done first is write unit tests. I think that t
Truncated by Planet PHP, read more at the original (another 4927 bytes)
Self-Contained Reusable Zend Framework Modules With Standardised Configurators

Posted: September 13th, 2009, 8:29pm MDT by Pádraic Brady

It was during last week, while writing out a draft chapter for Zend Framework: Survive The Deep End, that I found myself hitting a conceptual wall. If you are familiar with Zend Framework, you likely understand the concept of a Module in some detail. A Module is, in theory, a reusable collection of controllers, views and other classes which is packaged in its own directory for simpler copying or seperate treatment in a version control system like git or subversion.

The problem I had lay in demonstrated this fabled reusability. The more I tried to, the more I found myself throwing out cautions, warnings and advice on what to avoid doing. When it came to using Zend_Application, the trend continued since Zend_Application (a great component otherwise!) is just badly documented and explained. So off went another section just to try and explain its often confusing terminology. If you read the source code it all makes sense but if you don't the disconnect between the explanations and a user's expectations is obvious.

Reusability Rules

Zend Framework developers have, for better or worse, been ignoring the potential of modules for an interminably long time. It's not that big of a surprise given the focus of the framework has always been to present a use-at-will architecture which relies on loose coupling and independent components. Tight integration through overarching features (which don't break the framework's impressive orthogonality) like a command line tool or initialisation tools has long been neglected until very recently. Zend Framework 1.8 saw the long needed introduction of Zend_Application which offers standardised bootstrapping. Zend_Tool is another ongoing effort on the command line side.

The most typical example of a module in the literature is also the worst. An administration backend. It's a logical module since it's a completely separate system to the frontend, but it's the worst example because it is so very rarely reusable. Not every logical separation is reusable - they are mutually exclusive concepts. You could equally have a logical module which itself is comprised of several reusable modules and one non-reusable module. By definition, an administration backend is closely tied to CRUD operations against the application's domain model (at least to start with). Since each application will be different, the administration backend will also.

A far better example of a reusable module is something much narrower and focused. Consider a module dealing with User Management, or Paypal IPN integration, or implementing a blog aggregator. These are each common needs which, depending on the application, may require little change from implementation to implementation. Drop them in, configure them, integrate them, and you can have them working with few issues. Unfotunately, we keep focusing our module efforts on obviously non-reusable things like administration backends. Losing sight of the potential reuse of smaller subsystems will lead us to repeatedly developing them over and over again without even noticing this as a problem.

For the Zend Framework, this would be a big win. Rather than having developers re-implement commonly used web application systems it would encourage the distribution of third-party modules which would benefit from open source licensing and feedback. Imagine your next application requiring a minimal blog or integration with Paypal IPN and finding a third party module which does the trick so you can save some development time.

Achieving Reusability

When we discuss achieving reusability there are several factors and features covered when it comes to modules:

1. They are separated into their own parent directory.
2. They can apply specific configuration when accessed.
3. They require no special integration work.
4. Their classes are automatically available to the host application.
5. They are not required to contain controllers or views.

It's not an exhaustive list. Items 1, 4 and 5 are already a reality. Zend Framework modules do live in a module directory, using Zend_Application and some conventions their classes are autoloaded on demand and they are not required to contain controllers and views. A module may exist which merely offers models, helpers and some default forms.

So our path to reusable modules is hampered by items 2 and 3. Modules currently don't have on-access configuration unless we impose it through various means. This flows into integration work which is commonly needed to achieve this in the first place.

The Layout Example: Integration Through Front Controller Plugins

A simple example, taking our example administration backend (an "admin" module) is that of switching layouts. Suppose our main applicatio
Truncated by Planet PHP, read more at the original (another 31836 bytes)
Barcamp Hong Kong 2009

Posted: September 13th, 2009, 4:39pm MDT by Alan Knowles

Went along to Barcamp in Hong Kong this weekend, Have to thank all the guys & girls involved in organizing it. As it was a chance to meet some interesting people, who I did not realize where even in Hong Kong.

Barcamp Hong Kong, is perhaps a little different from what you might get elsewhere. First off it's not so much a techy thing. (Evidenced by the sight of 1 Linux desktop = mine...) I gave one talk on 'D', and went to a couple of others with lesser technical emphasis - drupal / OO JS etc. but the majority of talks where either business development style (raising funds, startups). or iPhone related (with out the coding stuff).

I guess this comes from the general attitude here that most programmers tend to regard it as a stepping stone to management or something, and have very little passion about the whole industry.. (as someone described it to me).

The technical talks gathered at most 20 people (out of I guess 200-300 people at the camp). And unfortunately, my talk/chat/discussion got rather hijacked by someone who wandered in, was completely non-technical, and started asking irrelivant questions. (self reminder, politely say, this is for programmers only next time)

Overall it was not much of a learning experience, rather the chance to actually meet developers with similar interests, (and see that they actually exist) - Shame I had to leave early for family stuff, as the drinks would have been good...
PHP Unconference Hamburg: a great event

Posted: September 13th, 2009, 4:03pm MDT by Stubblog - Planet PHP

This weekend I attended the PHP Unconference in the lovely city of Hamburg (if you don't count the wheather in). It was a really great event with a superb organisation, from my point of view even better then the some "professional" conferences. So, first a big thank you to the hosts from the PHP Usergroup Hamburg, you did a wonderful job.

Speaking about professional conferences, it's interesting to see that I'm not the only one with a very sceptical look on the International PHP Conference. Other attendees I spoke with had similar thoughts: always the same speakers with nearly the same topics, degrading the purpose of IPC to networking only. It would be more interesting with more fresh blood and a broader range of topics. Of course this would mean more risk for the host, but I believe in the long run the current development will ruin the IPC. Or can I just not imagine that there are so much companies out there paying several hundred Euros just for networking?

From the sessions I attended the Performance pessimization talk was really fun and insightful. Starting with an optimal (hardware) architecture Kris Köhntopp, Johann Hartmann, Stefan Priebsch and Lars Jankofsky made changes to this architecture to decrease its performance one after another. Both the audience and the speakers had very much fun in adding one "improvement" after another.

For the PHP in the Enterprise session I have rather mixed feelings. While Kris Köhntopp made some really good remarks on maturity of business models and their surrounding processes I think the whole session suffered from an undefined target. "Talking about Enterprise PHP" is not sufficient as session target. It was like a "Let's have a meeting on topic X, but we don't define an agenda for it." Well, from that point it was really enterprisy.

Together with Thorsten Rinne I did a presentation on Things to consider for testable code - I feel a bit sorry for Thorsten as his main purpose was to stress the important points of my presentation rather then talking about refactoring bad code to better code, the topic originally voted for.

To my surprise the audience seemed to appreciate it. I was very unsure if it would work out in the way I intended it. Probably I should add more examples for the Dependency Injection part as it was requested to see some real-life code, however I'm not sure how much it helped to better understand how it works. In every case I will add one or another point against Dependency Injection, as it seems that there are only benefits but no drawbacks. If you attended the session and would like to give feedback about what can be improved please drop a comment.

On sunday Oliver Müller (Btw, thanks to Oliver for taking us on a tourist tour around the Reeperbahn on saturday night. ) gave an interesting overview of current state-of-the-art technologies for implementing Single Sign-on systems. It raised new questions for a project I will do in the upcoming months.

Another interesting session was from Stefan Priebsch about the Model-View-Controler (MVC) design pattern. While I felt uncomfortable with the label "MVC" on Stubbles for quite some time now the talk finally convinced me to drop this label. MVC in the web is fundamentally different from MVC in desktop gui applications, where it was originally invented for, and there seems to be no common understanding of what MVC in web applications should really look like. That's not surprising as there are different solutions possible, and it strongly depends on the type and size of the application you create. Heck, there are even frameworks out there with a "Model" class you should inherit all your models from, which is ind
Truncated by Planet PHP, read more at the original (another 1201 bytes)
CalDAV - it's hard!

Posted: September 13th, 2009, 3:35pm MDT by Evert Pot

Over the past little while I've been working on a CalDAV library, and it's tough!

It appears that the spec is very much implemented with the client, rather than the server in mind. The spec writers have left no stone unturned, and it's technically possible to query the server for any odd dataset you might need. Aside from that the authors made absolutely sure there were no duplicated efforts, and built heavily upon the existing WebDAV, WebDAV ACL extensions and iCalendar.

While I generally agree it's a wise thing to not reinvent the wheel, I'm a bit of a pragmatist and feel the complexity of all these layers make it hard to understand, and must have played/will play a factor in the arguably slow adoption rate.

To keep it short, I feel the authors have over-engineered/abstracted the specification. Instead of making simple API's that work for 90% of the usecases, they have gone a much more generic route. This makes it very hard to predict how CalDAV clients will be using the server. Also, it makes it quite difficult to optimize and fit in a simple relational database or existing calendaring software. CalDAV should IMHO just have been a simple CRUD system. Advanced features and reports could have been made optional, and should have been specialized for common usecases.
Incomplete view of Web/CalDAV dependencies

This was a graph I used in an earlier post. There's actually a few more specs that are relevant to the implementor.
GroupDAV
GroupDAV deserves a mention here, as it attempts to address most of the issues I have. What it lacks is adoption from ICal, Sunbird and MS Outlook. The only issue I have is the frowned upon use of the PUT method (spec), where POST really should have been used.
Some examples
These will be highly uninteresting unless you have an intimate knowledge of the specs.

New calendars/events/todo's are created using PUT. This means the client now determines the unique id given to any of these objects. Most people will want to integrate CalDAV with systems which already have a different primary key, these people will be required maintaining 2 different id's and ensure there are never any duplicates. The id generated by the client can be any url encoded string. Note that this wouldn't have to be a problem if some POST statement would have been used.

CalDAV requires support for the expand-properties report from rfc 3253. In a nutshell the expand-properties report will look for WebDAV properties containing <DAV:href>url<DAV:/href>, follow these locally and add specified properties from these resources to the DOM. The benefit of this REPORT query is that less HTTP requests/roundtrips have to be made to make this work. The usecase for CalDAV specifically might be a lot simpler though, as it could mean something like 'get me the information of the user owning this calendar'. If it was instead simply required to add functionality that meets exactly that (and a few other usecases), it would be reasonably easy for me to write an optimized SQL query for those cases. Now I should support these lookup queries everywhere, because there's no good way to restrict how clients might use it.

CalDAV also requires fully implementing the ACL spec. The main usecase for this is calendar sharing. While the ACL specification will give you infinite complexity in how to setup your access control, it's quite a bit of work to even send back all the appropriate information and error messaging if you're not actually interested in this feature. Making ACL an optional extension to CalDAV would have been easier for implementers IMHO.
Self-Contained Reusable Zend Framework Modules With Standardised Configurators

Posted: September 13th, 2009, 1:03pm MDT by Pádraic Brady

It was during last week, while writing out a draft chapter for Zend Framework: Survive The Deep End, that I found myself hitting a conceptual wall. If you are familiar with Zend Framework, you likely understand the concept of a Module in some detail. A Module is, in theory, a reusable collection of controllers, views and other classes which is packaged in its own directory for simpler copying or seperate treatment in a version control system like git or subversion.

The problem I had lay in demonstrated this fabled reusability. The more I tried to, the more I found myself throwing out cautions, warnings and advice on what to avoid doing. When it came to using Zend_Application, the trend continued since Zend_Application (a great component otherwise!) is just badly documented and explained. So off went another section just to try and explain its often confusing terminology. If you read the source code it all makes sense but if you don't the disconnect between the explanations and a user's expectations is obvious.

Reusability Rules

Zend Framework developers have, for better or worse, been ignoring the potential of modules for an interminably long time. It's not that big of a surprise given the focus of the framework has always been to present a use-at-will architecture which relies on loose coupling and independent components. Tight integration through overarching features (which don't break the framework's impressive orthogonality) like a command line tool or initialisation tools has long been neglected until very recently. Zend Framework 1.8 saw the long needed introduction of Zend_Application which offers standardised bootstrapping. Zend_Tool is another ongoing effort on the command line side.

The most typical example of a module in the literature is also the worst. An administration backend. It's a logical module since it's a completely separate system to the frontend, but it's the worst example because it is so very rarely reusable. Not every logical separation is reusable - they are mutually exclusive concepts. You could equally have a logical module which itself is comprised of several reusable modules and one non-reusable module. By definition, an administration backend is closely tied to CRUD operations against the application's domain model (at least to start with). Since each application will be different, the administration backend will also.

A far better example of a reusable module is something much narrower and focused. Consider a module dealing with User Management, or Paypal IPN integration, or implementing a blog aggregator. These are each common needs which, depending on the application, may require little change from implementation to implementation. Drop them in, configure them, integrate them, and you can have them working with few issues. Unfotunately, we keep focusing our module efforts on obviously non-reusable things like administration backends. Losing sight of the potential reuse of smaller subsystems will lead us to repeatedly developing them over and over again without even noticing this as a problem.

For the Zend Framework, this would be a big win. Rather than having developers re-implement commonly used web application systems it would encourage the distribution of third-party modules which would benefit from open source licensing and feedback. Imagine your next application requiring a minimal blog or integration with Paypal IPN and finding a third party module which does the trick so you can save some development time.

Achieving Reusability

When we discuss achieving reusability there are several factors and features covered when it comes to modules:

1. They are separated into their own parent directory.
2. They can apply specific configuration when accessed.
3. They require no special integration work.
4. Their classes are automatically available to the host application.
5. They are not required to contain controllers or views.

It's not an exhaustive list. Items 1, 4 and 5 are already a reality. Zend Framework modules do live in a module directory, using Zend_Application and some conventions their classes are autoloaded on demand and they are not required to contain controllers and views. A module may exist which merely offers models, helpers and some default forms.

So our path to reusable modules is hampered by items 2 and 3. Modules currently don't have on-access configuration unless we impose it through various means. This flows into integration work which is commonly needed to achieve this in the first place.

The Layout Example: Integration Through Front Controller Plugins

A simple example, taking our example administration backend (an "admin" module) is that of switching layouts. Suppose our main applicatio
Truncated by Planet PHP, read more at the original (another 31414 bytes)
Going from closed source to open source

Posted: September 12th, 2009, 12:05pm MDT by Lukas Smith

I think I have mentioned Picok before on my blog. This is a system that lets users arrange and configure a number of portlets in order to be able to keep themselves up to date with what's going on in various web applications, similar to iGoogle and netvibes. The difference is of course that this system is entirely open source, so companies can install Picok in their intranet and give Picok direct access to all sorts of internal applications that they could not make available to iGoogle or netvibes. What makes this project all the more exciting is that this system was initially developed as a closed source application for the Raiffeisen bank in Switzerland. This was the first time for me, where I had the opportunity to be part of open sourcing such a large chunk of code.

One of the things we open source proponents mention as a plus point for open source is that developers do not easily get away with taking short cuts. All the internal ugliness is there for the world to see. Well I do take a lot of pride in all the code I develop and I am particularly thankful to Liip that they give me the opportunity and time necessary to write good code without the usual time constraints that come to later haunt customers. However you do take shortcuts, mainly because of various assumptions you can make about the setup. If you know and are able to closely define the server on which your app runs, you can of course safe a fair bit of time not coding for the general case. That is of course in the best interest of the client.

Now when I went to install Picok for the first time at a customer location, I realized just how many such assumptions existed in the code. I also began to realize how much knowledge is really stored in all the config files. How much our system relied on how Apache was setup in terms of file permissions and such. I also learned the hard way that before open sourcing, you should write a script that checks these assumptions. With the latest release of Picok we have a first step in this direction.

Another challenge that we had to meet was how to make it possible to support various client specific customizations. Raiffeisen is actually very forthcoming with letting us open source code. However there are several things in the system what we simply could not easily generalize. For example there are a number of features in Raiffeisen's version of Picok that are totally dependent on their corporate structure. Some of these we have stripped down and generalized. For example Picok can also work with a local user database instead of the external Lotus Notes user management system used at Raffeisen. They also have a few portlets that are based on internal closed source systems. In some cases they needed minor modifications to the Picok portlets. For example the currencyconverter portlet uses a free service to get the exchange rates. Raffeisen however wanted us to use their internal data source instead. All these customizations can have effects on the core logic, on the templates, on the CSS and/or the Javascript code.

The solution we came up with in the end uses numerous different approaches to make it as easy as possible to easily make Picok features available to the Raiffeisen version, while still making it possible for Raffeisen to pick and choose what they want and of course maintain their own look and feel according to their internal UI guidelines. At the core of this is the use of subversion externals. All the core classes are imported into the Raiffeisen this way. We then extend them in PHP. So while the base class that handles the frontend action methods is called api_command_portlet in Picok, we simply extend this class in the Raiffeisen version "class api_command_raiwebportlet extends api_command_portlet". Through some autoload magic we can automatically load the "api_command_portlet" class from a lib directory. We use a similar approach for the javascript code. With the CSS and translations files we have decided to always just merge by hand using a visual diff merging tool.

For the portlets we decided to go a different route. If we were to extend the portlets if would severely complicate things. Portlets would now have to be named "raiwebfeedreader" instead of just "feedreader". In the case of the command classes, all of this is fairly nicely hidden behind mod_rewrite magic, but the names of portlets are something people directly work with. Of course we could have tried to hide this somehow, but it would have added complexity we wanted to stay away from. So instead we are using "svn merge". Whenever want to add a portlet from
Truncated by Planet PHP, read more at the original (another 2682 bytes)
Book review: Mastering phpMyAdmin 3.1

Posted: September 12th, 2009, 8:30am MDT by Eirik Hoem

Mastering phpMyAdmin 3.1 Cover

Book review: Mastering phpMyAdmin 3.1
ISBN: 9871847197863
Publisher: Packt Publishing
Author: Marc Delisle

I had pretty much forgotten phpMyAdmin when I got a mail from Swati at Packt Publishing asking me to review this book. It’s been a very long time since I last used phpMyAdmin. When I first started out with web development (under Windows) and PHP I was hosted on a shared web host. They had phpMyAdmin installed as their main database management tool. With little to no knowledge on databases I was very happy to be able to do my basic list of operations to get stuff working. Needless to say I was a lightweight user.

Fast forward to today. I’ve moved on to Linux and the way of the command-line as many others, using the MySQL Gui Tools (Query Browser, Administrator) in addition. The tools from MySQL sure have their quirks and bugs, but they have mostly suited my needs for the last years. So, how does phpMyAdmin hold up, and is this the right book to get you started?

The book, written by Marc Delisle, clocks in at 326 pages, split into 18 chapters. The topics range from basic installation and database / table management to the “Multi-Table Query Generator” amd “The Relational System”.

The first few pages of the first chapter explains a bit background info on the software, which is pretty much skim-though-if-interested. More interesting, it covers installation for various platforms. The coverage on the installation parts can be a bit short for new users, but should be sufficient in most cases.

I especially liked chapters 2 and 3. Chapter 2 deals with authentication, which is pretty well covered, and the features are surprisingly extensive. Previously I was a bit reluctant to use phpMyAdmin in a production environment due to the lack of proper authentication, but these added features grants it a new evaluation. In chapter 3 the author spends time explaining the GUI itself and how it can be customized. Some parts of this section will definitely be interesting for people doing web hosting as it allows some branding of the software itself as well as laying down some ‘ground rules’ on the feature set to expose. In addition there are tips on user-centric adjustments for optimizing the work flow for the developer using the software. When using it on a regular basis this information is very nice to have.

Chapters 4 and 5 and 6 deals with database, table and data management. These chapters will probably be skim-trough material for most experienced developers, as the GUI is quite self-explanatory when it comes to these kind of actions. However, it’s worth mentioning that the author points out lots of configuration keys for controlling both the GUI, behavior and again features offered. Nothing is crucial for the lightweight user, but if phpMyAdmin is your main tool for the job you’d want to read these chapters in detail as well.

The coverage of exporting schemas and data is quite well done. Again I was surprised with the list of formats supported by phpMyAdmin. The author takes care to describe the various formats, as well as server-side requirements and how-to’s where applicable.

There is a chapter dedicated to searching, which I do not think needs a whole chapter on it’s own since it’s also very intuitive to use the GUI here. However, the chapter is quite short. The same goes for table and database operations which are also covered. Again I find the GUI clear enough fo
Truncated by Planet PHP, read more at the original (another 2111 bytes)
Solar 1.0.0alpha3 Released

Posted: September 11th, 2009, 2:37pm MDT by Paul M. Jones

The alpha3 version of the Solar Framework for PHP5 has been released; you can get it from the usual locations. Of note, this will be the last alpha release of Solar; I expect to have a beta released within the next 8 weeks or so. This entry is cross-posted from the Solar blog. I can’t believe [...]
Fall lineup

Posted: September 11th, 2009, 1:40pm MDT by Sara Golemon

It's conference season again, here's my schedule:

Code Works - San Francisco - Sep 23
I'm only doing the first city of the Code Works tour which happens to be in the region of the US I live in, so that's convenient. Here I'll be presenting an updated version of PHP 5.3: Hot or Not which went down pretty well in Chicago earlier this year at php|tek '09. This hour-long overview of the much anticipated next release of PHP will run through the laundry list of new features, language constructs, and APIs with examples of use, mis-use, and hopefully a two-way discussion of what features are most important to developers.

Later that same day, I'll blow the dust off the Navigating Streams presentation I gave in Mörfelden three years ago at IPC2K6. There's a lot more to do here as things have changed somewhat in the past three years, and the old slide deck is kinda boring. Expect a fresh rewrite of this run-through on PHP's filesystem layer and all the little goodies that have been hiding underneath it all this time which you might not have known existed.

PHPNW09 - Manchester, UK - Oct 11
For reasons unrelated to PHP, I kind of need to be... not in California for awhile. The 6,000 miles between here and England sounds like a good start, so when I mentioned this in IRC a couple nights ago, Lorna (one of the phpnw organizers) very quickly batted eyes and twisted my arm into volunteering for a speaking slot. Given the short term, I offered to just reuse one of the presentations I'll be giving at Code Works (since the audience isn't likely to overlap much). Long story short, my planned visit through the Peak District, then onto Yorkshire will be bisected by a diversion through Manchester where I'll deliver PHP 5.3: Hot or Not a second time.

ZendCon - San Jose, CA - Oct 21
Last, but not least, I'll be returning home to Silicon Valley for the fifth installment of Zend Con. Here, Eli's asked me to give the über-compressed one-hour version of my presentation on PHP Extension Writing. Frankly, I don't like trying to take what is about 8 hours of content and shove it into the spandex biker shorts of a one hour session. As usual, I'll do my best, and having done this topic at least once/year for the past four years my best isn't half bad, but be sure to buckle in when you arrive. Once I get started talking on this, I won't stop until the next speaker kicks me out, or someone raises a hand (and please, do ask questions as I go, everyone wins when you raise your hand).
Come to PHP Code|Works - you'll regret missing it

Posted: September 11th, 2009, 12:11pm MDT by Christopher Jones

Hey there! Kuassi Mensah and I will be presenting at the upcoming PHP Code|Works conference tour, which kicks off later this month. Code|Works is the latest generation of conference from the folk who, amongst other things, present the excellent PHP|Tek...
What Do You Develop On?

Posted: September 11th, 2009, 7:25am MDT by Stuart Herbert
At work, we have quite a variety of kit that we use for development:
1. Cheap and cheerful desktop machines w/ multiple monitors and plenty of RAM, normally with AMD CPUs. These machines mostly run some form of Linux … Ubuntu and Debian are both popular.
2. Various laptops, a fair mix of MacBook Pros and other kit running Linux.
3. Virtual machines running on the desktops and laptops, used for cross-browser testing.
4. Virtual machines running on HP servers and blades, used for system testing, release testing and production.
It gives us a lot of flexibility, allows us to develop and test on standards-compliant environments (but still use Windows for testing IE), and most of the time the developer is the bottleneck not the equipment Recently, I’ve added both a netbook and an Atom-based mini-itx machine into the mix, and this blog post is my attempt to recommend that you consider doing the same.

Netbooks are incredibly popular in the wider computer-owning population. Over here in the UK, they come free with many mobile broadband packages, making them cheaper than many low-end laptops. They’re sold in the supermarket and the high street. Their small form factor and relative lightweight makes them appealing to people who would never willingly cart a traditional laptop around. And they run Windows, which most people are familiar with.

After an initial explosion of innovation, the specs have settled around a 1.6GHz Atom processor, 1 GB of RAM and a 10″ 1024×600 resolution screen. That’s not a lot of power, and it isn’t a lot of screen estate. How do your websites look on a netbook? Does your home page or your landing pages make an impact at that size, or is your site’s message partially or completely below the fold? How do the rest of the pages look? If you’re creating an app, does the user have enough of a working area to comfortably do their tasks? Try using Google Reader or Zimbra on a netbook to see examples of what to avoid.

And how do your websites run on a netbook? Too much Javascript, and the pages won’t be snappy. The CPU won’t keep up, and the different latencies and throughput of mobile broadband make round-trips back to the server much more noticeable. Javascript that fires at regular intervals (e.g. rotating marketing spotlight images) can force the CPU to switch execution speeds, and so drain the netbook’s battery much quicker.

Testing on a netbook is one way you can spot and deal with these problems before your customers do.

Stuart is running a course in Manchester in October immediately before the PHPNW09 conference on how to setup and organise your PHP developers to ensure things run smoothly for you and your customers. Learn more about the course, or sign-up now.

Share This
Oh Be Careful Little Eyes What You See

Posted: September 11th, 2009, 6:57am MDT by Ibuildings Blog

The children's Bible song starts off with the line "Oh be careful little eyes what you see". Regardless of whether you agree with the religious doctrine behind the song, the advice from the first line is, none-the-less, applicable to the PHP community these days.

The web has made it easy for anyone to become an instant pundit, regardless of their background. The tools exist so that anyone can quickly and easily publish anything and call it a fact. Nowhere is this problem more visible than in the software development community at large and the PHP community in specific.

Continue reading "Oh Be Careful Little Eyes What You See"
Looking At PHP On Windows Adoption

Posted: September 11th, 2009, 6:52am MDT by Stuart Herbert
On Zend’s DevZone, Remi Woler recently talked about his experiences as a judge for the WinPHP contest organised through the Dutch PHP User Group and the Dutch PHP Conference. One of his closing remarks really stood out for me, where he was expressing his surprise at how few people participated: “I refuse to believe there are only a couple of dozen PHP developers in Europe.”

It’s an odd statement … the world and his dog knows that PHP is immensely popular over here in Europe. Perhaps Remi completely overlooked the Windows factor here?
1. I’ve been running a series of polls looking to learn more about the wider PHP community. One of the things that comes out of those polls is that 15% of developers use Windows as a platform, but only 3% are using Windows for their production platform.
2. At this year’s PHP UK Conference in London, Microsoft’s Hank Jansen (who heads up their open-source efforts) spoke in the main room. I wasn’t able to attend personally, but by all accounts his talk was not well-attended. Not only aren’t people using Windows, but the curiosity doesn’t seem to be there either.
3. Most hosting services (and practically all shared hosting services) are Linux based. If you want to host your site on Windows Server, there are plenty of firms offering this as an option, but many of these services are beyond the budget of many PHP projects.
My personal experience over the years is that many developers work in PHP on Windows because they’re working on laptops … and Linux on laptops continues to be a very hit-and-miss experience sadly. (They should all buy Macs instead ) About half of the larger corporations I’ve worked with in the UK prefer Windows Server because Linux skills are rare in their organisation, but these corporations were also reluctant to use PHP-based solutions, still wrongly seeing PHP as a hobbyist language compared to .NET or Java.

Share This
Train Your Employees

Posted: September 10th, 2009, 11:00pm MDT by Brandon Savage

Last week, Cal Evans retweeted James McGovern, who originated this tweet:

I’m not a fan of catchy sayings and one-line wonders, but this tweet got me thinking. How many companies, especially in the economic world we’re in, think about training as something that they don’t want to do, or an investment they can’t afford?

There are any number of reasons why companies don’t train their employees. Perhaps they made a financial decision that the business is doing fine, and such an investment doesn’t make sense. Perhaps they see their employees as interchangeable parts that can be replaced, and investing in a particular employee would represent a massive cost that might never be repaid by their productivity. Perhaps they figure that the employee’s job isn’t that important to the company to merit any sort of training.

But failing to train an employee, any employee, might be the biggest mistake a company can make. Employees are partially responsible for the success of the company. The most successful companies listen to their employees, and take their suggestions and ideas to heart. The least successful companies listen only to the executive team, as though that team is the only place where good ideas originate. But employees that don’t have the appropriate level of training, understanding and intuition will never generate the ideas to keep a business growing.

In technology this is especially true, because technology changes so frequently. Training employees in new technologies will help keep them in tune with the community, the development efforts, and the products on the market. In turn, this will make their ideas better, and their suggestions more business ready. And the dividends will pay.

As for whether or not those “investments” you made will walk out the door, remember this: Microsoft spends millions every year on its Research and Development operation just to keep pace. Most large companies do the same, because they realized a long time ago that while sometimes the money might be wasted, having the next big idea could be a huge game changer in any industry. They’re not afraid to spend money in search of new business opportunities, and neither should you. Training is a key component of that, and without it, new ideas won’t flow into your business the way you need to keep on top of your market.
Extending Zend Server GUI – Data Cache Information

Posted: September 10th, 2009, 7:40pm MDT by Zend Developer Zone

As the GUI of Zend Server is based on the open-source Zend Framework, you can easily extend it. This article demonstrates how to integrate new functionality to Zend Server which makes it possible see the content and some meta information of cached items. For this example I use the Data Cache API from Zend Server, but in combination with the Zend Framework component Zend_Cache and its Zend_Cache_Backend_ZendServer_Disk backend adapter.
Forty Percent!

Posted: September 10th, 2009, 12:46pm MDT by Paul M. Jones

Big news (for me anyway): my employer, OmniTI, is allowing me to spend a minimum of 40% of my paid work time on the Solar Framework for PHP 5 (plus additional time as duty allows). The project remains open-source under New BSD license. The agreement has been in place for several weeks now, and has [...]
SabreDAV 0.12

Posted: September 10th, 2009, 10:38am MDT by Evert Pot
I just released a new version of SabreDAV, 0.12. I've skipped on posting for the last few versions, because I didn't want to get too spammy on this blog.

These were mostly bugfixes, and a few added features. SabreDAV is also a PEAR-package again, so installing is as simple as 'pear install SabreDAV-0.12.0.tgz'.

Download it here.
Full list of changes
- Added: Experimental PDO backend for Locks Manager.
- Fixed: Sending Content-Length: 0 for every empty response. This improves NGinx compatibility.
- Fixed: Last modification time is reported in UTC timezone. This improves Finder compatibility.
- Fixed: Issue 13.
- Added: now a PEAR-compatible package again, thanks to Michael Gauthier.
- Added: Plugin to automatically map GET requests to non-files to PROPFIND (Sabre_DAV_Browser_MapGetToPropFind). This should allow easier debugging of complicated WebDAV setups.
- Added: Ability to choose to use auth-int, auth or both for HTTP Digest authentication. (Issue 11)
- Fixed: TemporaryFileFilter plugin now intercepts HTTP LOCK requests to non-existant files. (Issue 12)
- Updated: Browser plugin now shows multiple {DAV:}resourcetype values if available.
- Added: generatePropfindResponse now takes a baseUri argument.
- Added: ResourceType property can now contain multiple resourcetypes.
- Added: Sabre_DAV_Property_Href class. For future use.
- Changed: Made more methods in Sabre_DAV_Server public.
- Added: Central list of defined xml namespace prefixes. This can reduce Bandwidth and improve legibility for xml bodies with user-defined namespaces.
- Changed: moved default copy and move logic from ObjectTree to Tree class.
Speaking at the PHPNW09

Posted: September 10th, 2009, 3:48am MDT by Thomas Weinert

I will speak at the PHPNW09 in Manchester.

Optimizing Your Frontend Performance Take a look on web application performance from the users side. The session starts from the browser, showing tools to measure and analyze performance and takes you to the server, explaining headers and possible solutions.

Looking forward to answer your questions and hear from your experiences and solutions.
Creating Modular Template-Based Interfaces with Savant

Posted: September 9th, 2009, 1:32pm MDT by Zend Developer Zone

It's generally considered a good idea to separate the functional business logic of a Web application from its user interface. And a good template engine helps you achieve this separation with minimal fuss and muss. This article introduces Savant, a lightweight, OOP-compliant template engine with some unique features that offers an effective solution to the problem of controller-view separation.
pearweb bugtracker overhaul

Posted: September 9th, 2009, 12:03pm MDT by Christian Weiske

After four weeks of hacking, the completely renewed patchtracker integration into PEAR's bugtracker went online. Working with patches is much smoother now, the patch feature being integrated fully into the bug tracker.

Up to now, using patches in pearweb felt like using a standalone tool apart from the bugtracker. Now, everything is integrated making it a pleasure to upload, compare, override and download patches.

Apart from the patchtracker enhancements, many bugs have been fixed - the page is completly xhtml valid, an (early) print stylesheet for bug lists has been added, and links are finally underlined, which makes them much easier to detect on the page.
Messages from the past

Posted: September 9th, 2009, 12:03pm MDT by Christian Weiske

Every month, PEAR developers receive a mail from pear.php.net containing a list of open bugs and feature requests for their packages.

Last month, my mail listed a feature request as "open" although I had set it to "won't fix" a week before. I put it on my TODO list, but did not have the time to investigate further.

This month, Craig Constantine sent a mail to the PEAR developer mailing list, asking why he was receiving mails although he was inactive. Nobody knew. People on #pear began to investigate: Checking the code, executing the code on our lovely CI server with a copy of the live data.

Nothing. Not the slightest trace of a problem, except for those mails. We were clueless until someone asked if the mails were really coming from our database - and our server. A look at the mail headers shed light on the problem: The mails had been sent from pb12.

pb12 hosted pear.php.net unil January 2009, when we ditched it for the new euk1 box. After moving the website, nobody actually removed the pearweb code, database or cron jobs - and nobody setup the reminder cronjob on the new server, letting the issue go unnoted.

We were really getting messages from the past - from an old system that was forgotten, but still running.
Mobile Content Security

Posted: September 9th, 2009, 9:25am MDT by Paul Reinheimer

Securing content without proxying through PHP is a pretty common, and easily solved problem. You get Li [httpd] (or any other webserver) to check some sort of a hash when it serves content. In the hash you include the users IP address, a timestamp, and probably the path to the file. This solution works remarkably well for the average desktop user. Sure there's outliers behind non-sticky load sharing proxies, but most people confidently ignore that portion of their user base.

Mobile users present a more serious problem. Their IP changes more frequently, under a large number of circumstances. As users move from tower to tower, or as their carrier changes moods their IP changes, generally within the same subnet. That last statement there provides almost a tease as to a possible solution: only hash a portion of the IP address to allow for greater flexibility.

Problems however, go a bit deeper.

As devices get smarter, we're now able to do nifty things like surf the web at home (on our mobile device) using our WiFi connection. As we walk outside and down the street the device seamlessly fails over to the 3G, Edge, or whatever connection and our browsing session continues. The browser being blissfully unaware of the change can do nothing to help us. During a test over the weekend, I saw tens of thousands of instances of switching within the same subnet, and a few thousand instances of changes beyond. This is a real problem for a mobile site.

In order to solve the problem I've had to balance a few needs: our need to provide even a modicum of protection for our content, the needs of our users to have links work when they view a page. To balance these I've added some checks to our software that determine if a user's IP changes, when those changes are detected the secure links generated omit the IP address but use a far more aggressive timeout. Hopefully balancing our need to protect content, with our desire to serve it to expectant customers.

Have you solved this problem differently?
Sys/DB Admin and Coder Seeks Others To Build Web “A-Team”

Posted: September 9th, 2009, 9:20am MDT by Brian K. Jones
UPDATE: There’s no location requirement. I kind of assume that I’m not going to find the best people by geographically limiting my search for potential partners.

Me: Live in Princeton, NJ area. Over 10 years experience with UNIX/Linux administration, databases and data modeling, and PHP/Perl. About 3 years experience using Python for back-end scripting and system automation, and less than a year of Django experience. Former Director of Technology for AddThis.com (it was bought out), Infrastructure Architect at cs.princeton.edu, and systems consultant/trainer. Creator of Python Magazine, former Editor in Chief of both php|architect *and* Python Magazine, and co-author of “Linux Server Hacks, volume 2″ (O’Reilly).

You are one of these:
- Web graphic designer who has worked on several web-based projects for clients in various industries, understands current best practices and standards, has the tools and experience necessary to create custom graphics, and has some familiarity (secondarily) with PHP and/or Python, Javascript and Ajax. If you regularly make use of table-based web designs or ActiveX controls, this isn’t you.
- Hardcore web developer with at least 6 years experience doing nothing but web-based projects using Javascript and (at some point) *both* PHP and Python, and has worked with or has an interest in Django, Cake, and other frameworks, and understands that client needs often don’t coincide with the religion of fanboyism. Knowledge of Javascript, Ajax, web standards and security is essential here. If your last “big project” was volunteer work to build a website for your kid’s soccer team, this isn’t you.
- A generalist webmaster (sysadmin/db admin/scripter) with at least 6 years experience working in production *nix environments with good familiarity in the areas of high availability, web servers (specifically Apache), proxy servers and monitoring, and has worked with/supported users like the ones mentioned above on web-based projects. If you have to look at the documentation to figure out how to implement a 301 redirect, this probably isn’t you.
Experience working on a team in larger projects with multiple people would be good. Note that I’m looking for people to partner with on projects, I’m not hiring full time employees. Future partnership in a proper business is certainly a possibility, but… baby steps! I do have a couple of domains that would be great for use with this kind of project if it ever progresses that far

I know that other people are out there looking for people to partner with on projects, but there doesn’t appear to be a common place for them to interact. Maybe that can be a project we undertake together — if there *is* a place where people meet up for this kind of thing, let me know!

Let’s have fun, and take over the world! Shoot me an email at “bkjones” @ Google’s mail domain.
<script type="text/javascript"> addthis_url = 'http%3A%2F%2Fwww.protocolostomy.com%2F2009%2F09%2F09%2Fsysdb-admin-and-coder-seeks-others-to-build-web-a-team%2F'; addthis_title = 'Sys%2FDB+Admin+and+Coder+Seeks+Others+To+Build+Web+%26%238220%3BA-Team%26%238221%3B'; addthis_pub = 'jonesy'; <script type="text/javascript" src="http://s7.addthis.com/js/addthis_widget.php?v=12" >
Managing software deployments of your PHP applications II

Posted: September 9th, 2009, 9:20am MDT by till
This is not (really a part) two of my series, but an Intermezzo (1) between Part I and Part III — because I have no time to finish Part III.

In Part I, I talked about my approach to deploying a website and I offered pear and subversion as solutions to the problem. To briefly elaborate on my subversion part, I want to share the following Capistrano recipe with you.
Capistrano, isn't that Ruby?
Yes it is! Capistrano is a nifty piece of software. Not because it's so super-duper complex, but because it's pretty robust and works really well.

I am sure everyone heard of the "the right tool for the job" theory and this is along those lines. Please don't be afraid of a little Ruby to ease the deployment process. (They don't deserve your fear anyway. ;-))
Installation
On FreeBSD:
```
cd /usr/ports/devel/rubygem-capistrano && make install clean
```
On Debilian/Ubuntu:
```
apt-get install rubygem
gem install capistrano
```
Go on and create a capfile in $HOME, and this is where we'll keep our tasks.
If You Code, You Should Write

Posted: September 9th, 2009, 8:14am MDT by Brian K. Jones
The Practice of Programming
Programmers are, in essence, problem solvers. They live to solve problems. When
they identify a problem that needs solving, they cannot resist the temptation
to study it, poke and prod it, and get to know it intimately. They then start
considering solutions. At this point, the programmer is not often thinking in
code — they’re thinking about the problem using high-level concepts and terms
that most non-programmers would understand.

Consider the problem of how to post a news story to a website. The programmer
might think about the solution this way:
- Log in
- Go to ‘new story’ page
- Enter title and text
- Press ’submit’
Of course, there are a million details in between those points, and after them
as well. The programmer knows this, but defers thinking about details until the
higher-level solution makes sense and seems reasonable/plausible. Later in the
process they’ll think about things like the site’s security model, WYSIWYG
editors, tags and categories, icons, avatars, database queries and storage, and
the like.

Once they’ve reached a point where they’re satisfied that their solution will
work and is thoughtful of the major points to be considered in the solution,
they open an editor, and begin to type things that make no sense to their
immediate family. Programmers express their solutions in code, of course, but
they express them nonetheless, and this is not a trivial point.
The Parallels Between Programming and Writing
Writers often take the exact same course as do programmers. Programmers and
writers alike are often given assignments. Assignments take the form of a
problem that needs solving. For a programmer it’s a function or method or class
that needs implementing to perform a certain task. For a writer it’s an article
or column or speech that covers a particular topic. So in these cases, the
problem identification is done for you (not that more discovery can’t be done
– in both cases).

Next is the conception of the solution. Programmers puzzle over the problem,
its context in the larger application or system, its scope, and its complexity.
Writers puzzle over their topic space, its breadth and depth, and its context
in the bigger picture of what their publication tries to accomplish. In both
cases, writer and programmer alike take some time and probably kill some trees
as they attempt to organize their thoughts.

At some point, for both writer and programmer, the time comes to use some tool
to express their thoughts using some language. For a writer, they open a text
editor or word processor and write in whatever language the publication
publishes in. For the programmer, they open an IDE or editor and write using the
standard language for their company, or perhaps their favorite language, or (in
rare cases), the best language for accomplishing the task.

In neither case is this the end of the story. Programmers debug, tweak, and
reorganize their code all the time. Writers do the exact same thing with their
articles (assuming they’re of any length). Both bounce ideas off of their
colleagues, and both still have work to do after their first take is through.
Both will go at it again, both with (hopefully) a passion that exists not
necessarily for the particular problem they’re solving, but for the sheer act
of solving a problem (or covering a topic), whatever it may be.

Finally, once things are reviewed, and all parts have been carefully
considered, the writer submits his piece to an editor for review, and the
programmer submits to a version control system which may also be attached to an
automated build system. Both may have more work to do.
Starting Out
The process is essentially the same. If you’re a new programmer, you can expect
to have more than your fair share of bugs. If you’re a new writer, you can
likewise expect your piece to look a bit different in final form than it did
when you submitted it to the editor.

Just like programming, writing isn’t something you do perfectly from day one.
It’s something that takes practice. At first it seems like an arduous process,
but you get through it. As time passes, you start to realize that you’re going
faster, and stumbling less often. Eventually you get to a point where you can
crank out 1500-2000 words on your lunch hour without needing too much heavy
revising.
You Should Write
So, I say “you should write”. As someone who owes his career to books and
Truncated by Planet PHP, read more at the original (another 1833 bytes)
Fast XML parsing with Ruby

Posted: September 9th, 2009, 7:54am MDT by IONCANNON

One of the first things I needed to do while building the GeeQE iPhone application was process the CC data dump from Stack Overflow. The dump contains XML files representing tables from Stack Overflow with the largest file being posts.xml weighing in at 1.2G as of September. I decided it would be pretty easy to use Ruby to parse the XML and load the data into MySQL so I went about finding the right parser for the job.

If you haven't processed large amounts of XML before one thing to realize is that you don't want to use a DOM parser because it is going to load the entire XML structure into memory. What you want is a SAX parser that can work on the XML stream as it comes in. With this in mind I started looking around and quickly found an older benchmark post that gave me an educated guess that the LibXML library was going to be the fastest parser for Ruby. After figuring out how to use it I decided to also give a couple other libraries a shot to see how they stacked up, the other two I looked at were REXML and Nokogiri.

The following is a set of example using each library in streaming SAX mode. Each processes the 1.2G posts.xml file from the dump and does nothing more than check that the element represents a "row". I have also included a sample runtime for each:
REXML SAX example require 'rubygems'
require 'rexml/document'
require "rexml/streamlistener"
include REXML

class PostCallbacks
include StreamListener

def tag_start(element, attributes)
if element == 'row'
# Process row of data here
end
end
end

source = File.new "posts.xml"
Document.parse_stream(source, PostCallbacks.new)

REXML runtime
time ruby rexmltest.rb
real 47m22.871s
user 42m0.711s
sys 3m31.943s Nokogiri SAX example require 'rubygems'
require 'nokogiri'
include Nokogiri

class PostCallbacks < XML::SAX::Document
def start_element(element, attributes)
if element == 'row'
# Process row of data here
end
end
end

parser = XML::SAX::Parser.new(PostCallbacks.new)
parser.parse_file("posts.xml")

Nokogiri runtime
time ruby nokogiri.rb
real 4m45.347s
user 4m7.504s
sys 0m19.332s LibXML SAX example require 'rubygems'
Truncated by Planet PHP, read more at the original (another 2660 bytes)
The importance of bad code (or, WordPress and why I am a psychic)

Posted: September 9th, 2009, 7:54am MDT by Marco Tabini

Note: this is my exit(0) column for the August issue of php|architect, written well before the recent WordPress worm hit many high-profile bloggers asleep at the upgrade switch. Besides the fact that, obviously, I'm a psychic and your company should hire me to divine its future, I thought that this piece would be particularly relevant to the discussion at hand. I'll be entirely honest and say that I don't like WordPress—but it's also high time that people realize that if when you install a piece of software on a server, you also take the responsibility of keeping it up to date. Bitching at the WP folks because they didn't make that process easy until recent versions is no excuse for the fact that you dropped the ball.
PHP is, as I am fond of saying, the language of people who get things done. Getting things done, however, doesn’t always mean that the end result will be pretty—in fact, I believe we can all agree that there is much “ugly” PHP code in the wild (and let he—or she—who is without sin write the first unit test).
What is interesting about ugly code is that, like a coffee stain on the new living room carpet, it just doesn’t want to go away—it sticks around, makes itself at home and awaits the next developer who comes along and notices it. Meanwhile, the underlying product thrives, becomes popular and grows—and so does its codebase.
There are a number of very popular open-source products that could arguably benefit from a good, old-fashioned code audit; in all fairness, there are probably a good number of very popular closed-source products that could probably benefit from the same—we just don’t get to see how ugly their code actually is. A number of PHP community members have, recently, analyzed the code that belongs to several PHP-based OSS packages—content management systems and e- commerce engines seem to be popular targets—and determined that many of them ignore common best practices and contain code that is either poorly documented or difficult to maintain.
And yet, these packages thrive. They build huge communities, gain large followings and, generally speaking, often become the catalyst of bona-fide revolutions in their markets. Some of the most popular content management systems are PHP based and have grown organically from very humble beginnings—which they still retain, at least in part, to this very day. Far from being a liability, the perhaps less-than-stellar coding standards have, in fact, become assets: programmers who collaborate on these projects are encouraged to look for results without placing undue emphasis on form.
There are, of course, limits to the tolerance of the “relaxed” coding practices that these projects have. The implosion of phpBB that happened a few years back—when even Google was forced to intervene in order to stop a worm from causing widespread damage—sent out a very clear message: security is not something anybody can compromise on, regardless of how inexpensive or popular their product is.
By and large, however, bad code is a phenomenon that matters little, if at all, to the end user—it’s the results that make all the difference. Several open- source PHP CMS systems have functionality that rivals—and in many cases far surpasses—their commercial counterparts without coming with the same steep (and, let’s face it, sometimes absolutely ridiculous) price tags.
What can we learn from all this? Simple: that we need bad code. The importance of peer review and critique is important—and, therefore, so is the work of those community members who are taking the time to examine the code that is found in these open-source projects—but so is the unique ability that many of these products have demonstrated in building features, attracting communities and gaining a popular place in the marketplace.
What is really great about this line of thought is that the existence of bad code is, in fact, a win-win for everyone: users get what they want at a very low cost; developers can learn to improve their code from their peers; and community members can learn from each other how to build code that others want to use.
Formatting valid xs:dateTime fields with PHP

Posted: September 8th, 2009, 2:01pm MDT by Stefan Koopmanschap

Recently I had to compose some XML documents that needed to be validated with XSDs. All fine of course, but I had some problem with two date/time fields that according to the XSD were supposed to be xs:dateTime fields. Googling around I found a lot of references to the ISO8601 format, so I decided to format my date using the DATE_ISO8601 constant. That did not work though.
The php|a Podcast Episode #2 is out

Posted: September 8th, 2009, 8:54am MDT by Marco Tabini

In case you don't follow it, a new episode of the php|architect Podcast is out. Much to my surprise, I have discovered that I like doing these—I even got over my dislike of my own voice.
Check it out—thanks mostly to a great group of guests, this episode is really cool.
Zend Framework Book: Surviving The Deep End - Chapter 10 Released! Zend_View, Zend_Layout, html 5 and YUI CSS

Posted: September 8th, 2009, 7:32am MDT by Pádraic Brady

It's been a busy few weeks but I've finished and released Chapter 10 of the Zend Framework: Surviving The Deep End book!

The new chapter explores setting up the example blog application's web design using Zend_View and Zend_Layout. I also spend some time exploring html 5, the future standards update for html. I decided to employ html 5 mainly because it's rather fun and interesting to get it working today and learn more about where it may impact web applications and web design in the future. The web design itself makes use of the Yahoo! User Interface Library's CSS components.

I've also gotten around to sorting the book's source code availability. This is explained in the book's introduction with detailed instructions. The source code is being stored on a git repository hosted by Github.com at http://github.com/padraic/ZFBlog. The specific source code for a chapter is tagged as "Chapter-XX" where XX is the chapter number. This should save everyone from copying the source from the book directly if all they want is the final set.

Finally, let me reiterate that feedback is truly welcome! You can add comments at the end of every single chapter or, if very specific, to any paragraph. The intent of this detailed commenting system is to gather the ideas, criticisms and corrections readers come up with so the final edition (before Zend Framework 2.0 hits!) is as useful, correct and worth reading as possible. So do leave comments or ask questions at the end of chapters!

Zend Framework: Surviving The Deep End is a free online book about the Zend Framework licensed under a Creative Commons Attribution-Non-Commercial-No Derivative Works 3.0 Unported License.
Free Performance with MySQL Table Types

Posted: September 7th, 2009, 11:38pm MDT by SitePoint Â» PHP
Last week, SitePoint launched its second Twitaway, giving away a free PDF of The Principles of Successful Freelancing to anyone kind enough to follow us on Twitter. Predictably, the site we built for readers to claim the PDF was swamped with traffic in the first few hours of the giveaway, and the MySQL server behind the scenes quickly ground to a halt.

First, a little background: at the time of our first Twitaway in 2008, Twitter HQ had been kind enough to relax the limit it places on the maximum number of Twitter direct messages (DMs) that it would allow us to send in a single day. To distribute the free PDFs, then, we simply wrote a PHP script that would look through our Twitter followers every few minutes, identify the new ones and send them a DM with the download link.

This time around, when we sat down to plan Twitaway 2009, it was clear our job would be more difficult. Much less cooperative than they had been previously, Twitter HQ stonewalled our requests to relax the daily DM limit—they wouldn’t even tell us what our daily limit was. For awhile there, we weren’t sure how we would be able to deliver a download link privately to our Twitter followers.

The solution finally came from Mal, a new developer on the team here at SitePoint HQ. We would use Twitter’s new OAuth support to request temporary access to your Twitter account, use it to verify that you were indeed following us, and then simply display the PDF download link in your browser. No DM required!

Of course, writing a PHP application that supported this OAuth-based workflow was a lot more complicated than writing a static web page with a “follow us on Twitter” link. Not only would it be harder to write, but it would be harder to handle large amounts of traffic hitting it, too.

So there we were: just past midnight on launch day of the Twitaway, and the application had stopped responding. Our monitoring systems made it clear that, while our PHP servers were weathering the storm nicely, the MySQL database server had spiked to 100% CPU usage, stuck its fingers in its ears and begun rocking back and forth, chanting “na-na-na-na-na-I’m-not-listening!”

As it turned out, this was an important lesson for our development team about the importance of choosing appropriate MySQL table types. Read on for how we solved the problem, and why we should have predicted it.
Choosing The Right Table Type
When we logged into the swamped MySQL server, we could see (using the SHOW PROCESSLIST command) that the overwhelming majority of the queries that it was receiving were for the database table we had set up to contain PHP session data.

By default, PHP stores your users’ session variables in files on the web server’s hard drive. In our case, however, we had multiple web servers that all needed to share the same session data, so we had configured PHP to store its sessions on the MySQL database server instead.

Unfortunately, we had failed to specify a table type when creating the session table in the database:
```
CREATE TABLE sessions (
  sesskey VARCHAR(32) NOT NULL DEFAULT '' PRIMARY KEY,
  expiry INT(11),
  expireref VARCHAR(64),
  sessdata LONGTEXT
);
```
MySQL supports a number of different storage engines. When you create a table, by default MySQL will use the MyISAM storage engine to create a MyISAM table. MyISAM is a relatively simple table type, which forgoes several advanced features in order to offer improved performance. In the early days of MySQL, the MyISAM table type was instrumental in making it one of the best performing databases around.

These characteristics would seem to make MyISAM a natural choice for something like a session data table. Unfortunately, MyISAM has an achilles heel: table-level locking. In order to write a change to a MyISAM table, MySQL must lock the whole table, preventing any other query from reading the table until the change is complete.

As thousands upon thousands of SitePoint readers flocked to our Twitaway site to claim their book, multiple PHP processes competed to create, update, and read session data in this single table. And because of MyISAM’s table-level locking, they had to do so one at a time, waiting their turn on an increasingly backed-up database server.

On the surface, the "/>
Truncated by Planet PHP, read more at the original (another 4234 bytes)
Peer Review: Improving The Business Logic

Posted: September 7th, 2009, 11:00pm MDT by Brandon Savage
This entry is part of an ongoing series involving the review of a code sample and it’s refactoring. For the original code sample, see here.

So far, we’ve done quite a bit of work on our Twitter class, making it better. There’s still work to be done, though, especially improving the logic.

The Twitter class we have now has a number of logical flaws in it that we need to address. Additionally, there are some logical flaws that we started with that I want to highlight, even though we’ve already fixed them. Let’s get started with those.

When we started, we were setting the host [www.twitter.com] in the constructor, and then concatenating it in the tweet method. But we were setting it as an object-level property. Let’s look at that code:
```
$this->host .= "statuses/update.xml?status=".urlencode( stripslashes( urldecode($message )));
```
This is a bad practice for one reason: it makes the object unusable a second time! If we ever use the object again, we’ll end up concatenating the message onto the end of the last message and getting a 404 error. Not good.

We’ve fixed that by setting the host inside of the HTTP object. Good.

I also have to ask: is an HTTP status code of 0 ever acceptable as a result? According to the author of this class, Twitter sometimes returned a status code of 0 but was successful in sending the tweet. However, Twitter ALSO returns a JSON or XML response, which is much more effective for determining the success (or failure) of a particular tweet. I’m going to assume that getting the response gives us pure JSON, and using the Twitter API documentation to make some assumptions. Let’s take a look at the bottom of the tweet() method:
```
		// STATUS UPDATE ON TWITTER
        $this-> [http->setHost(] this->baseHost . "statuses/update.json?status=".urlencode(stripslashes(urldecode($message)));
        $this-> [http->setCredentials(] this->user, $this->pass);
        $this-> [http->setOption(HTTPRequest::RETURN_TRANSFER,] true);
        $this-> [http->setOption(HTTPRequest::POST,] true);
        $response = $this-> [http->execute();]         $array = json_decode($response->getRaw(), true);

        if(isset($array['id']) AND $array['id'] > 0)
        {
        	return TRUE;
        }
        return FALSE;
```
That’s much better. Now, we’re evaluating whether or not the tweet has an ID that is greater than zero, meaning that if anything else is returned, we know the tweet was unsuccessful.

We still have some logic issues to sort out, though. People who use Twitter know that occasionally it fails. If it fails while we are attempting to tweet, we could run into some problems because the already_tweeted() method inserts our tweet into the database BEFORE the tweet is actually sent. This is a huge logical problem.

Thankfully it’s an easy one to solve, by breaking the already_tweeted function into two functions: checkTweet(), and logTweet().
```
	/**
	 * Check to see if this tweet has already been posted.
	 * @param string $message The tweet
	 * @return bool
	 */
    protected function checkTweet($message)
    {
       	$hash = md5( date('Y-m-d') . $message );

        $c = new Criteria();
        $c->add(TwitterLogPeer::THASH, $hash);
        $count = TwitterLogPeer::doCount($c);

        if($count > 0)
        {
        	return TRUE;
        }

        return FALSE;
    }

    /**
     * Log the tweet if it has already been tweeted.
	 * @param string $message The tweet
	 * @return bool
	 */
	protected function logTweet($message)
	{

	   $hash = md5( date('Y-m-d') . $message );

        try {
			$logTweet = new TwitterLog();
			$logTweet->setDate(time()); // This will be turned into a DateTime object.
			$logTweet->setHash($hash);
			$logTweet->setTweet($message);
			$logTweet->save();
        } catch (Exception $e) {
        	throw new Exception('There was an error in saving the item to the database.');
        }

        return TRUE;
    }
```
These logical fixes will improve the overall logic of the class. There are still a couple of considerations that the developer might want to take into account. The biggest consideration is that the process of verifying that we’re not sending the same tweet will work well, except over midnight server time. This is a small consideration, however, and you might consider whether fixing this presents a significant value.

Also worth considering is whether or not the object should even verify
Truncated by Planet PHP, read more at the original (another 5174 bytes)
What's on your desk?

Posted: September 7th, 2009, 4:10pm MDT by Marco Tabini

For some reason that I do not quite understand myself, I have always been fascinated by other people's desks. This is not a fetish of mine—far from it, it's genuine interest in understand how others set up their workstations.

There's a lot to be learned about the way someone works by observing the way they set themselves up for work. Besides, you never know when you may learn a trick or two just by watching how someone else solves the same problems you face every day.

Therefore, I have a challenge for all my readers—show me your desk. You can just upload them to flickr and give them the desksurvey tag. Don't forget to add a little description of what you think makes your desk unique. I plan on collecting some of the most interesting response and post them in an article for phparch.com (thus, please license your pictures on a CC/share-alike license).* Leaving me a comment would also help :-)

To get the ball rolling, I'll start with my desk:

Although I have a "formal" desk and office, most of the time I don't work on it. My kitchen (assuming I am around the house) doubles as my office instead—much, I must admit, to the chagrin of my wife.

There are a couple of reasons for this. First, I do not actually need anything other than my computer and my mouse to work—and I can do without the latter in a pinch, since a laptop is now my main machine. I also do not need any reference materials—all my books, magazines and other relevant purveyor of day-to-day information is available to me in electronic format wherever I go (except private information, which stays safely in the office inside an encrypted external hard drive).

More importantly, however, I like to work in an informal environment—particularly where I can see outside (my "real" office faces a wall). It's not at all uncommon for me to simply pack up my laptop in its pouch and drive over to our nearby park during the summer—bandwidth courtesy of my cell phone.

So… what's on your desk?

*Note: I know this is not an original idea, and I don't care. I just want to see what other people who read my blog have on their desk.
New article: Graphs in the database, SQL meets social networks

Posted: September 7th, 2009, 2:40pm MDT by Lorenzo Alberton

Graphs in the database: how to store a graph data structure in a DBMS, and answer the most common queries typical of social networks, like "You might also know" or "You might also like", or "How you are connected to XYZ" (degrees of separation).
Speaking at PHP NorthWest 09

Posted: September 7th, 2009, 10:06am MDT by Stefan Koopmanschap

Last year I was a speaker at the PHPNW08 conference in Manchester. It was a great conference and I've met some wonderful people there. We even held a short symfony update meeting there in one of the rooms during a break. I am happy to announce I will be a speaker again this year at the PHPNW09 conference!
Migrating a dev team to an OO team (Part 1)

Posted: September 7th, 2009, 8:57am MDT by Ibuildings Blog

For many years Object Oriented Programming was rare in the PHP world. Many PHP programmers donât know OO simply because PHP isn't natively an OO language. But with PHP5, PHP really entered the world of objects.

Still many PHP programmers feel that OO is too much for PHP. They don't see the benefits of object oriented programming. This is the start of a series of blog posts to investigate the topic.

Continue reading "Migrating a dev team to an OO team (Part 1)"
Content management starts with the repository

Posted: September 7th, 2009, 8:16am MDT by Henri Bergius

Gadgetopia makes an argument for building your own CMS:

"See — the problem with a full scale Content Management System is that it has too many opinions. Those opinions were though of by somebody other than you and the needs of your organization. The more developed a content management system (or any piece of software, really) the more “opinions” it has. And the more “opinions” it has, the more likely one of them is going to really tick you off."

I can relate to this. We work with one system in particular that makes an astonishing array of presumptions about how you’re going to use it, and if you try to step outside those presumptions, demons fly out of the abyss and try to suck your eyeballs out.

This goes back to a previous discussion we had about Content Management as an API. In that post, we had a great experience with hand-rolling a CMS...

The term they are looking for is Content Repository, a service that provides common APIs for content storage, retrieval, signaling and so forth. With Midgard we're following this approach, providing content retrieval and web functionality APIs first, and then building some reusable user interfaces on top of that.

In addition to Midgard some content repositories to look at include Apache CouchDB and Jackrabbit. All of them allow you to stop worrying about storage and retrieval methods and focus on the actual end user functionalities, while keeping the whole system accessible and scriptable for integration purposes.

Technorati Tags: couchdb, jcr, midgard
Extreme Programming: Vortrag@Mayflower-Würzburg

Posted: September 7th, 2009, 1:23am MDT by ThinkPHP /dev/blog - PHP

Am kommenden Donnerstag, den 10.09.2009 findet wieder ein öffentlicher Vortrag im Mayflower Büro in Würzburg statt (Pleichertorstrasse 2, 97070 Würzburg, Straßenbahn Congress Centrum).
Beginn ist um 18:00 Uhr, Thema des Vortrags ist Extreme Programming.

Passt XP zu unserem Projekt? Wozu noch eine weitere agile Methode? Ist XP erfolgreich? Diese und andere Fragen wird Michael Krieg während des Vortrages erörtern und beantworten. Er wird die Rahmenbedingungen zur Etablierung von XP in den eigenen Softwareprojekten beschreiben und praktische Tipps zu "GO"s und "NO-GO"s geben. Am Ende des Vortrages darf sich jeder aus dem agilen "Baukasten" bedienen und selbst entscheiden, welche Komponenten für sie oder ihn passen und ob XP tatsächlich die Projektmethodik der Wahl ist.

Die Donnerstags-Vorträge werden sowohl in Würzburg als auch in München gehalten. Bei Interesse einfach das Blog beobachten, um auf dem Laufenden zu bleiben!
Wir freuen uns auf viele Teilnehmer!

Größere Kartenansicht
Join Me In Manchester In October For Training

Posted: September 7th, 2009, 12:12am MDT by Stuart Herbert
October in Manchester is home to the PHPNW09 conference. Last year’s conference was a great event, and this year’s promises to be even better. And I’m not just saying that because I’m a conference sponsor this year, honest

Immediately before the conference, I’m running a two day tutorial in the fundamentals of setting up and running a team of PHP developers, covering:
- Keep your promises to your customers using written specifications
- Organise your team using Subversion and Trac
- Control quality using code reviews
- Deliver to your customers using release management and follow-up support arrangements
- Where to go after the course for additional learning
Places are limited to just 25 people, and there is an early-bird discount for anyone who signs up before 21st September. You can find out more on the course website, and sign-up online.

Share This
The Beginner Pattern

Posted: September 6th, 2009, 8:15pm MDT by blog.phpdeveloper.org Â» PHP
You were there once, remember? You were the cautious explorer, venturing out into an unknown language with little idea what it might hold in store. You learned functions, found tutorials to help you take your first steps and maybe even reached out to other developers to help you along the way. You were a beginner – everyone has to start somewhere, after all – and every little bit helped.

So, it worries me when I see things like this talking about a move of the PHP community away from those introductory topics that we all came to know and love as we moved forward into our PHP development careers. Samuel doesn’t think it’s the PHP community’s fault, not by far. He does suggest, though, that we’re “forcing newcomers to our community to build their PHP homes from attic to basement” by not pointing out or writing up as many tutorials and articles targeting the introductory developers.

In the spirit of trying to bring PHP back to the masses, I’m going to suggest a “design pattern” of sorts that the PHP community can help to bring even more people into the language and help them really find the heart of the language and what it’s all about:
- Learn – The first step in the pattern is to learn about the task you’re trying to accomplish. Obviously you can’t teach others if you don’t know about it first. Find out the best way to do it – the tips and tricks if you can – and remember them. They’ll come in handy in the next piece of the pattern.
- Write – You don’t have to be the Hemingway of PHP to write a tutorial. This piece has an obvious fit with the first step of the process. Take what you’ve learned and write it up into something anyone can follow. Just posting a list of commands and code isn’t enough – sorry. Write it so that someone who doesn’t know anything about the topic can pick it up and run with it. Plain english (or whatever your native language is) is best…technical terms are good when they’re needed, but don’t try to use them to make yourself look important by using too many multisylabic words in too many places con only lead to trouble. And remember, tutorials don’t have to be about anything fancy. Find out something cool about an everyday PHP function? Write it up! Trust me, no one will think anything about an “advanced developer” writing about a cool thing they figured out about str_replace.
- Share – Obviously, a good tutorial or article isn’t any good unless people know about it. Sharing is an integral part of this pattern. If you don’t let others know, you might as well not write it. You never know when someone might need a little nugget of the wisdom you’re sharing, so broadcast it out there. Don’t be ashamed to bring it to the masses in the forums or post about it on your blog. There’s nothing wrong with a little self-promotion if you can help out some developer in need with exactly what he needs.
- Learn – Wait, this again? That’s right, the pattern loops back on itself in an endless cycle. Once you learn a new skill, write about it and share that knowledge with at least one other person, you’re back where you started. You’re moving forward in your development and coming across new challenges each day. So, guess what? Write about them! Share it! You get the idea…
The pattern is simple Learn then Write then Share. Learning is handled by one object (you) and then writes to a local resource (your brain, duh) and the resources are exported into external data sources for other objects to use. Simple, right?

So, go out there, learn something new, write a tutorial about it and share it with the masses. Idling in your development on a project? Think about the things you’ve learned so far and share those.

Remember, there’s new developers starting every day – help them out and share the tips and tricks you have stored in that head of yours. They’ll thank you for it.

Photo from pagedooley Creative Commons Attribution License
SymfonyDay Cologne 2009

Posted: September 5th, 2009, 11:21am MDT by Stefan Koopmanschap

In the past week I have been very excited about symfony Day Cologne, and now that it's over, I was right to be excited. What a wonderful event it was! It was very nice to meet all the people, and I had a great time doing my workshop.
Upload in modal window and pass values with jQuery

Posted: September 5th, 2009, 6:18am MDT by Web Development Blog Â» PHP scripts

This PHP / jQuery tutorial explains how-to upload a file PHP from ThickBox and how after successful upload the filename is passed to the parent document. The function is a useful addition for custom content management systems.
Speaking at PHPNW09

Posted: September 4th, 2009, 5:27pm MDT by Michelangelo van Dam

It's almost fall again and it's amazing to see how many great conferences are scheduled. Seems impossible to choose between great talks given by the best developers worldwide.

One of those great conferences is held in Manchester, UK. It's PHPNW09 with an awesome schedule listing well known and lesser known people from the international PHP community (like Stefan Koopmanschap, Derick Rethans, Lorna Mitchel, Rob Allen and many more). This year I'm on stage too talking about the Standard PHP Library or SPL.

Something that I really like about the PHP community is that we all help each other getting better at the things we do. After I gave my SPL talk at DPC 09 earlier this year, I got so many responses and pointers on the presenter rating site Joind.in which were very helpful improving this presentation.

So, if you have a day to spend on PHP, come and join us at PHP North West conference 2009. Prices are reasonable and flights are fairly cheap compared to the massive information overload you're about to absorb there.
Mail_Queue: 1.2.3

Posted: September 4th, 2009, 11:05am MDT by till
Despite Mail_Queue being a PHP4-compatible package, I still like to use it on current projects because it is so easy to implement and because it gets the job done. So, over the last weeks (and especially since PHP moved from CVS to SVN :-)), I put in a little time, and especially with the help of Ken, we managed to push out the 1.2.3 release today.
What's new? changed license from PHP to the (New) BSD license
This is good news for two reasons. Numero uno, GPL-licensed (open source) projects may bundle Mail_Queue now since the (new) BSD license is compatible with the GPL. And secondly, because (re-)releasing the code using this well-known license also gets rid off another entry barrier for commercial entities and also provides them with enough flexibility to use this code inside commercial applications.
bug #7850
This one is a tough one, and only bites you if you really adhere to backwards compatibility (aka BC) and work with an older code base. ;-)

So the story is, that with PHP4, a constructor cannot return a PEAR_Error object. PHP4 also did not have exceptions. So what we implemented as a work around it, and of course to keep BC, was to introduce a new "factory" method (which can return a PEAR_Error object). In addition to the factory, we added helper methods (Mail_Queue::getErrors() and Mail_Queue::hasErrors()) so you can check the state of the class at any time.
bug #14626
This one's self-explanatory — and the only real bugfix in this release.
minor CS fixes
To make the PEAR test suite happy. :-)
request #15049
We added a method to count emails in queue. This is currently only implemented when you use the MDB2-based backend. (Side-note: DB, MDB and creole backends are deprecated!)
request #14921
Implemented optional support to sleep() in between the sending process — to not hammer mail servers.
request #6456
Additional parameter validation to deal with PHP's loosely typed variables.
requests #16064, #16068
These are Ken's contributions to the Mail_Queue release — callback support to run a custom function whenever an email was send (or queued on the SMTP side). This could be used to provide extended monitoring and metrics on the sending process. Yay!
Installation, or upgrading
Existing install:
```
pear upgrade Mail_Queue
```
New install:
```
pear install Mail_Queue
```
There is nothing else to do. All new features are optional, and nothing requires you to touch your code base. The beauty of BC!
What's next?
I added a roadmap for 1.2.4 last night, but I'm not sure if we will really get to it. I'm trying to channel all efforts to Mail_Queue2 (which is a PHP5-only port of Mail_Queue and already contains most (if not all) the features included in Mail_Queue's 1.2.3 release. If you would like to contribute, please check out the project on Google Code and let me know your thoughts.
Silence of the LAMPs

Posted: September 4th, 2009, 5:49am MDT by ThinkPHP /dev/blog - PHP

(based on a true story)
A well-known but discouraged operator in PHP is the silence operator @, that supresses any output, that a particular command may yield. Read on to find out how you should not use it.

Continue reading "Silence of the LAMPs"
Speaking at PHPNW09

Posted: September 4th, 2009, 3:54am MDT by Lorna Mitchell

I have experience of PHP conferences from all possible angles - as an attendee, as a speaker and as an organiser. At PHP North West this year I will be taking this to new heights and combining all three roles into a single one-day conference. I have a speaking slot at the event entitled "Passing the Joel Test in the PHP World", which I'm very excited about. Its a talk that I think brings together the best ideas from a general software engineering world and puts them into the context of PHP development. If you're wondering what the Joel Test is, then you can read about it on wikipedia.

Having spoken at a few different events now, some local and some quite high-profile PHP conferences (OK, so php|tek - the event of the year!), I'm really delighted to be bringing my ideas to the local conference that I help to organise and attached to a user group full of bright and interesting people. The experience of launching a call for papers, submitting my own abstracts, and then trying to figure out where it fits in when evaluating the CfP was a bit split-personality but with Jeremy's input we decided this was a good fit - and I'm looking forward to delivering it!

The event itself is in Manchester, UK on Saturday 10th October and there is only one week remaining on the early bird ticket price!! So all those people who think its ages away and you'll sort out arrangements nearer the time - you have been warned. The schedule is world-class (quite literally, these speakers do speak right around the world), and the price is pocket money (50 GBP + VAT until 11th September). As well as the technical content you get a fun weekend in Manchester, plenty of social activity, there's more geekery happening the following day and all attendees get a 12-month subscription to php|architect magazine to keep them learning all year long. Now you're persuaded - you can buy you tickets here and let me know to expect you!

PHPNW is the highlight of my year - I hope to see you there :)
How Midgard and Midgard2 differ

Posted: September 4th, 2009, 1:57am MDT by Henri Bergius

I had to make some updates to the architecture diagrams, and I thought to publish them here to showcase the difference. Midgard was a CMS framework for PHP:

Midgard2 is a more universal content repository where CMS is just one application:

Please note that more choice in databases and web servers is not the only goodie provided by Midgard2. You also get things like a completely rewritten MVC framework, database views, transactions and native datetime objects. And all of this for multiple programming languages, not just PHP.

Technorati Tags: midgard
Presentation Zen Vortrag@Mayflower-München diesmal!

Posted: September 4th, 2009, 1:14am MDT by ThinkPHP /dev/blog - PHP

Am kommenden Donnerstag, den 10.09.2009 findet wieder ein öffentlicher Vortrag im Mayflower-Büro in München statt (Mannhardtstraße 6, S-Bahn Isartor). Beginn ist um 18:00 Uhr, Thema des Vortrags ist Presentation ZEN " und wird von Johann-Peter Hartmann gehalten.

"...Vorträge von Entwicklern sind einfach. Die Fachthemen werden priorisiert und hierarchisch geordnet. Die Hierarchie wird "Agenda" genannt, und jedes Thema ergibt eine Folie, die alle Stichworte als Bulletpoints auflistet - welcome to the PowerPoint Hell. Genau 5 Minuten nach Beginn des Vortrags werden die Mails gechecked, nach 7 Facebook, und die Schnarchgeräusche ab Minute 10 lassen sich auch durch lautes Sprechen nicht mehr übertönen. Zwei Wochen kann sich der Zuhörer noch genau an den Titel der Präsentation erinnern, der Inhalt ist vollständig vergessen.

Um das zu verhindern hat Garr Reynolds Presentation ZEN entwickelt. Mit ZEN meint er "Zurückhaltung, Einfachheit und Natürlichkeit" und verspricht, dass am Ende mehr hängenbleibt - und es auch mehr Spaß macht. Scheint zu klappen: Er ist der Typ, der mit den coolen Apple-Präsentationen angefangen hat..."

Die Donnerstags-Vorträge werden sowohl in Würzburg als auch in München gehalten. Bei Interesse einfach das Blog beobachten, um auf dem Laufenden zu bleiben!

Wir freuen uns auf viele Teilnehmer!
Technology of the day: Zend Server

Posted: September 3rd, 2009, 2:39pm MDT by Daniel Krook

A few months back, Ed Kietlinski introduced us to the new Zend Server at a New York PHP meeting. I’ve since installed it on two of my department’s servers and put together some notes on my experience. Update: See the comments section for some configuration suggestions from Zend that differ from the steps I followed. [...]
Cool Mac/Mobile Software for Sysadmins, Programmers, and People

Posted: September 3rd, 2009, 1:55pm MDT by Brian K. Jones
I recently upgraded my primary workhorse (a MacBook Pro) to Snow Leopard. Before I did, I decided to go through and take stock of all of the documents and software I’d accumulated. While I was doing this, I simultaneously got into a conversation with a buddy of mine about the software he uses on his Macs. Turns out he maintains a whole page devoted to (mostly non-geek, but still somehow geeky) Mac software he uses.

I decided to go ahead and list the software I use for stuff whether it was geeky or not. Then I realized that pretty much all of the software I use is kinda geeky. I guess if you’re someone who’s going to create a list of software you use, it’s pretty hopeless.

So… here’s what I’m using. Suggestions welcome in the comments!
Social Media
- Tweetie
- Twitterlocal
- Tweetdeck
- TweetGrid
- Brightkite (iPhone)
- LinkedIn
My Twitter account updates my Facebook status. My Brightkite checkins update the location information on my Twitter account. It also sends a tweet… which updates my Facebook status. I pay less attention to the ongoing status in my LinkedIn account, but it gets updated automatically as well, I just don’t remember how or by what anymore.

I’ve tried a bunch of Twitter clients. Tweetie is “good enough”. It’s the one I use most often. If I need something hardcore I use Tweetdeck or TweetGrid, which has the benefit of being web-based.

TwitterLocal lets you put in your location and a radius, and then shows you tweets from people who are discernibly near you. I think Brightkite does a better overall job with this, since its whole reason for being is to be location-aware, but it seems like I get fewer updates than with TwitterLocal.
Communication
- Colloquy
- Tweetie
- Mail
- Skype
- Google Talk
Right. Twitter is also a communication tool. I have, in fact, checked in with people via Twitter. It’s not how I typically use it, but I think it counts

I have to use both Skype and Google Talk because I’m on the road a lot (I’m a consultant) and there are enough hotels who do stupid things with their network that I’m forced to use whichever one works on that particular network. Though I mostly use GMail for mail, it’s gone down a few times on me, so it’s good to have Mail around. I’ve recently found GMail notifier to be almost useless as well, so when I use Mail, I find that getting alerted to incoming messages frees my brain. I use Mail.appetizer to show me previews of incoming mail so I don’t have to switch gears from what I’m doing to see the latest spam. Note, however, that it’s not quite ready for Snow Leopard.

I haven’t tried Mail in Snow Leopard yet. If they ever fix the search functionality (I find it useless) I’ll stop using the GMail interface. I’ve tried thunderbird, but its search is even worse (or was, the last time I tried it).
Fun Stuff
- GarageBand
- Flickr Uploadr
- iPhoto
- StellaOSX
- Sim City 4
I play guitar and piano, and have also played drums, saxophone, and lots of other noise-making apparatuses. I like that GarageBand will let me put down bass and drum tracks without having to own a bass or drum set.

I also enjoy photography, though I don’t often get out on long quiet hikes in nature or gastronomical adventures that would make for the kinds of stunning things I see on Flickr all the time. However, I do have a family, and we do travel, so while not even 10% of my pics on Flickr are stock quality photos, at least 90% of them are interesting to me personally

iPhoto I see as a necessary evil these days. I used to love it, but now that it tries to help me out by autocategorizing on things that, as it turns out, are pretty arbitrary in the context of my life, I don’t like it as much. It’s good for quick touc
Truncated by Planet PHP, read more at the original (another 11870 bytes)
PHP in schnell

Posted: September 3rd, 2009, 12:50pm MDT by till

Sorry, this is all in German. Or at least Germenglish. ;-) The slides are not rocket science and show a basic introduction to "faster PHP". Things to do, things to avoid, some autoloading and a little on "shared nothing" in the end. There are some speaker-notes included (link) to make the slides more valuable for those who couldn't make it.

Hier die Folien zu meinem Vortrag "PHP in schnell" bei der PHP Usergroup in Berlin im September 2009. Leider sieht man unten keine Notizen (speaker notes). Man kann sie jedoch sehen, wenn Ihr über folgenden Link (Actions > Show speaker notes (Vorsicht: Rechtschreibfehler usw. inklusive)) die Präsentation öffnet.

Wer Fragen hat, darf gerne kommentieren oder mich einladen. ;-)

Vielen Dank an alle die da waren. Und Danke an den NewThinking Store Berlin für den Ort, Beamer, Internet und das Glas Wasser. ;-)
Don’t refactor without unit tests

Posted: September 3rd, 2009, 7:56am MDT by PHP in Action » PHP

Image by niallkennedy via Flickr
Brandon Savage is writing a series on code improvement using a code example (starting with Peer Review: Taking Code And Making It Better). In other words, it’s about refactoring, which is practically my favorite subject. Although I don’t agree with all of it, it’s mostly good advice. I recommend it.

That said, I do have something important to add. The series is missing the first, most basic rule: Don’t refactor unless you have good automated test coverage (typically with unit tests). And if there are no test, write them before you start refactoring. If you don’t, you’ll make mistakes and get lost in a frustrating bug search, unless you’re very stingy and don’t refactor too much. With test coverage, you have freedom to experiment, to change something and change it back if you don’t like the result. This, above all, is what makes refactoring such a great learning experience.

Some of those who have commented on the post Peer Review: Looking Into Abstraction (Greg Beaver, Jeff Carouth) mention testing and point out the need to inject objects so that they can be replaced with mock objects for testing. This is a wise move, and practically unavoidable in this case. To support refactoring, unit tests need to be run frequently, without accessing outside services (twitter or email in this case) that take time to process.

This means that in this case, it’s actually necessary to refactor a bit before proper unit tests can be implemented. This is what Michael Feathers calls the Legacy Code Dilemma in his book Working Effectively with Legacy Code. Certainly building this dilemma into new code is not a good idea. Make the code unit-testable before it’s too late.
<script src="http://static.zemanta.com/readside/loader.js" type="text/javascript">
Judging the winPHP contest, or 10 tips to make the cut

Posted: September 3rd, 2009, 6:52am MDT by Zend Developer Zone

Early April, Cal Evans approached me with the request to judge the winPHP contest, from a community point of view. After some questions on what the role of a judge implied, I agreed with the contest. During the time the contest ran, I followed the blog posts and tweets about the winPHP contest, and was getting excited to review all those great applications. I figured the judges would be busy as hell in the time between the end of the contest and the announcement of the winners. Seeing all those great contributions, I was actually starting to fear my days of DPC would be filled with application reviewing. It did not exactly turn out that way…
Searching through archive files

Posted: September 3rd, 2009, 4:35am MDT by Johannes Schlüter
To learn a bit about PHP Gtk I'm working on some small GUI application to read the PHP manual, quite rough and the sole purpose is to play with PHP Gtk. People who know me know that I really love iterators in PHP so obviously this app is using iterators, too. In this post I want to share an example where iterators are really useful:

As said the app is about browsing the PHP manual. The manual is provided as tar.gz to the app and I wanted to have a fulltext search. For accessing the tar.gz content I'm using phar. Yes, phar is not only for phar files but can work on different kinds of archives (tar.gz, tar.bz2, zip), too.
So that's my search implementation:
```
class FullTextSearch extends FilterIterator {
    protected $needle;
 
    public function __construct(PharData $archive, $needle) {
        $flags = RecursiveIteratorIterator::LEAVES_ONLY;
        $it = new RecursiveIteratorIterator($archive, $flags);
        parent::__construct($it);
 
        $this->needle = $needle;
    }
 
    public function accept() {
        $current = $this->current();
        // This is not 100% perfect but should be good enough for this case:
        if (strpos($current->getFilename(), '.htm') === false) {
            return false;
        }
 
         // This is bad for larger files ...
         $content = file_get_contents($current->getPathname());

         return strpos($content, $this->needle) !== false;
    }
}

$needle = 'search';
$archive = new PharData('php_manual_en.tar.gz');

$search = new FullTextSearch($archive, $needle);
foreach ($search as $filename => $fileobject) {
    echo "Found in $filename.\n";
}
```
The code has some places marked which might need some improvements for general purpose but shows how nice iterator-based solutions can be.

If you aren't used to iterators you most likely wonder what's going on, so let's look into it:

First we need some basic knowledge. An Iterator in PHP is, basically, an object that can be used in foreach statements and does something - an ArrayIterator, for instance, walks over an array returning all the array elements. Now PharData objects are RecursiveDirectoryIterators. This means you can put the phar data object into a foreach statement and you'll get a list of all files - oh wait it's not that easy. Actually you will receive only the root elements. Confused? - On the one hand I said it's recursive but on the other hand it only returns the root elements? - Well having a RecursiveIterator means that the object provides methods to check whether the current element has children and can provide an Iterator to iterate over these children. foreach won't call these methods - that's the job of the RecursiveIteratorIterator (RII). The RII is a so-called outer iterator which means it iterates over the elements of another iterator. In this case it will walk over the files in the archive and will, for every file, check whether it is a directory. In case the current entry is an directory it will work, recursively, in that directory till all files were returned.

Having this basic knowledge we could write code like this:
```
$it = new RecursiveIteratorIterator($archive);
foreach ($it as $filename => $fileobject) {
    echo $filename."\n";
}
```
This gives use a list of all files and directories in the archive. The next thing I'm having in the first snippet is a FilterIterator. A FilterIterator is - again - an outer iterator doing exactly what the name says: It filters the elements from it's inner iterator. For that it calls the accept() when stepping to the next element. If accept() returns true the element is given to the caller (being the foreach statement or another iterator) if it returns false the element is ignored and the FilterIterator checks the next element. So in this case I only care about elements containing the needle from my search.

With all this there's just one little thing left in the code: Treating directories like file and searching through them won't work and in this case I absolutely don't care about the directories themselves so I ask the RecursiveIteratorIterator to step over the directory handles and directly go to the children.
EU to probe Oracle Sun deal

Posted: September 3rd, 2009, 4:05am MDT by ThinkPHP /dev/blog - PHP

According to Yahoo News (and WSJ, only for subscribers - thanks to @Oswald for mentioning it on twitter, see also Reuters), the EU opens an in-depth probe to the Oracle-Sun deal.

According to the source, EU Competition Commisioner Neelie Kroes said:

"The (European) Commission has an obligation to ensure that customers would not face reduced choice or higher prices as a result of this takeover,"

Furthermore, the commision set a January 19, 2010 deadline for its decision, Yahoo News said.

PS: U.S. already approved the deal.
Compressed protocol for mysqlnd

Posted: September 2nd, 2009, 3:00pm MDT by Andrey Hristov

Compressed protocol support for mysqlnd has ready alpha patch. Tested with simple queries, not tested against the test suite or big packets.
PHP North West 2009

Posted: September 2nd, 2009, 9:55am MDT by Ibuildings Blog

10th October 2009 sees the second annual PHP Conference to be held in Manchester, PHP North West. As one of the organisers I've been watching the arrangements come together with growing excitement: this year we have a new venue, a schedule literally packed with excellent sessions, plenty of social activity, and some community-driven input on Sunday morning - I'll even be speaking myself this year. Some of the topics at this year's conference include various PHP frameworks, performance, Drupal, project management, and much more.

The conference is a regional event aimed at PHP developers of all levels as well as their managers, coming together and exchanging ideas around developing PHP within teams today. Our attendees range from those living locally or making a daytrip of it right across to speakers and attendees flying in from mainland Europe. We're very grateful to all our sponsors, they've stepped up to get involved even in the difficult economic climate and without them this entirely volunteer-organised conference simply couldn't happen.

Continue reading "PHP North West 2009"
PHP – Faster And Cheaper. Scale Vertically with IBM Power Systems

Posted: September 2nd, 2009, 9:49am MDT by Zend Developer Zone

Get your PHP project done faster and save money by scaling it vertically with IBM Power Systems
Converting ICalendar to XML

Posted: September 2nd, 2009, 9:25am MDT by Evert Pot

I've started working on a CalDAV implementation, which also requires analysis of ICalendar (rfc 2554) objects.

ICalendar objects have properties, components (such as VEVENT, VTODO) and attributes. This is awfully familiar to XML. So instead of trying to come up with a complicated parser and object structure, I decided to just convert it to XML and use PHP's simplexml.

This is my current script:
<?php function iCalendarToXML($icalendarData) { // Detecting line endings if (strpos($icalendarData,"\r\n")) $lb = "\r\n"; elseif (strpos($icalendarData,"\n")) $lb = "\n"; else $lb = "\r\n"; // Splitting up items per line $lines = explode($lb,$icalendarData); // Properties can be folded over 2 lines. In this case the second // line will be preceeded by a space or tab. $lines2 = array(); foreach($lines as $line) { if ($line[0]==" " || $line[0]=="\t") { $lines2[count($lines2)-1].=substr($line,1); continue; } $lines2[]=$line; } $
Truncated by Planet PHP, read more at the original (another 15149 bytes)
PHP DOM XML extension encoding processing

Posted: September 1st, 2009, 2:48pm MDT by Zend Developer Zone

I recently worked with PHP's DOM XML extension while working on Zend Framework's Zend_Search_Lucene html highlighting capabilities, and uncovered some undocumented features and issues with the extension in regards to character encoding. The information contained in this article should also apply to other libxml-based DOM implementations, as PHP's DOM extension simply wraps that library.
Sending e-mails via SMTP with PHPmailer and Gmail

Posted: September 1st, 2009, 1:40pm MDT by Web Development Blog Â» PHP scripts

Using the SMTP server from Gmail is a good choice for mail application with less than 500 recipients a day. This tutorials shows you how to send mail messages via SMTP using PHPmailer and Gmail.
Poll: Have you adopted PHP 5.3 yet?

Posted: September 1st, 2009, 1:36am MDT by Stuart Herbert

Earlier in the year, before PHP 5.3 was released, I asked the community a series of questions about their attitudes towards moving to PHP 5.3, and had a fantastic response. I’m going to turn all of those answers into a new conference talk that I’m working on.

Now that PHP 5.3 has been around for a few months and we’ve started seeing plenty of blog posts covering all the new features in PHP 5.3, I’m wondering whether or not you have actually moved to PHP 5.3 yet. I’m especially curious to see how this compares to what people said they’d do before it came out

Please vote on twtpoll to let me know if you have moved to PHP 5.3, and if not, what’s still stopping you. Many thanks in advance!

Share This