The more the merrier of course, so if you’re in the Toronto area and have an interest in open web technologies, come on out and join us! Details are on Guestlist.

Google have implemented an alpha of the WebFinger protocol. If you have a Google profile, click on “Edit your profile” and add ‘webfingeralpha’ as an interest. Congrats, your gmail address is now a WebFinger identifier and will resolve to an XRD file containing information about services you use (if you’ve included that information in your Google profile).

This is pretty fun to play around with. Given an email-like identifier, such as evalpaul@gmail.com, get the host-meta XRD file for the domain:

paul@knuth ~ $ curl -i http://gmail.com/.well-known/host-meta
HTTP/1.1 200 OK
Content-Type: application/xrd+xml
Transfer-Encoding: chunked
Date: Mon, 01 Feb 2010 12:36:47 GMT
Expires: Mon, 01 Feb 2010 12:36:47 GMT
Cache-Control: private, max-age=0
X-Content-Type-Options: nosniff
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN
Server: GFE/2.0
...

<?xml version='1.0' encoding='UTF-8'?>
<!-- NOTE: this host-meta end-point is a pre-alpha work in progress.   Don't rely on it. -->
<!-- Please follow the list at http://groups.google.com/group/webfinger -->
<XRD xmlns='http://docs.oasis-open.org/ns/xri/xrd-1.0' 
     xmlns:hm='http://host-meta.net/xrd/1.0'>
  <hm:Host xmlns='http://host-meta.net/xrd/1.0'>gmail.com</hm:Host>
  <Link rel='lrdd' 
        template='http://www.google.com/s2/webfinger/?q={uri}'>
    <Title>Resource Descriptor</Title>
  </Link>
</XRD>

Now that you have the URI template, get the XRD file for the specific user:

curl "http://www.google.com/s2/webfinger/?q=acct%3Aevalpaul%40gmail.com"

<?xml version='1.0'?>
<XRD xmlns='http://docs.oasis-open.org/ns/xri/xrd-1.0'>
	<Subject>acct:evalpaul@gmail.com</Subject>
	<Alias>http://www.google.com/profiles/evalpaul</Alias>
	<Link rel='http://portablecontacts.net/spec/1.0' href='http://www-opensocial.googleusercontent.com/api/people/'/>
	<Link rel='http://webfinger.net/rel/profile-page' href='http://www.google.com/profiles/evalpaul' type='text/html'/>
	<Link rel='http://microformats.org/profile/hcard' href='http://www.google.com/profiles/evalpaul' type='text/html'/>
	<Link rel='http://gmpg.org/xfn/11' href='http://www.google.com/profiles/evalpaul' type='text/html'/>
	<Link rel='http://specs.openid.net/auth/2.0/provider' href='http://www.google.com/profiles/evalpaul'/>
	<Link rel='describedby' href='http://www.google.com/profiles/evalpaul' type='text/html'/>
	<Link rel='describedby' href='http://s2.googleusercontent.com/webfinger/?q=evalpaul%40gmail.com&amp;fmt=foaf' type='application/rdf+xml'/>
</XRD>

The workshop was fairly interactive with people from the audience asking questions or raising points every so often. It was a pretty diverse group professionally speaking, made up mostly of software developers, technologists, designers and some marketing people. The material wasn’t very technical, which I found disappointing, but given the crowd it was the only thing that made sense (I guess for some reason I expected more developers).

The real take-away of the workshop was an overview of various open standards and protocols that can be used together as a sort of Open Web stack. The usual suspects were discussed: OpenID, OAuth, PubSubHubub and a few that were fairly new to me: Portable Contacts, Activity Streams and the Salmon Protocol. Chris also spoke a bit about the Mozilla Drumbeat project which certainly looks interesting.

At the end of the workshop we got into groups and brainstormed about how social web technologies could be used to create a better web. I co-opted my group to talk about how FreshBooks (my employer) could be made more social. Some really interesting ideas were brought up and I think it’s a great case study for working with a community that already exists (as opposed to building a community for a new social application).

The workshop was great. I’m glad I had the opportunity to participate and I definitely came away with a few thoughts and ideas. For one, it could be a worthwhile project to document existing or create new open source projects that use open web technologies. Often it’s easy to find sample code, but it’s usually stripped down and not very useful. Real, concrete examples from open source projects could be extremely useful for developers looking to implement support for open technologies and protocols.

First, a disclaimer. I know that there are some historical reasons for a lot of these things (i.e. Exceptions not appearing until PHP5) but that doesn’t change the current reality. Consider for instance filesystem functions in the standard extension:

$lines = file("/tmp/file.txt");

If the file “/tmp/file.txt” does not exist, depending on your php.ini settings (because display_errors should always be ‘Off’ on production systems), you may get something similar to the following output:

Warning: file(/tmp/file.txt) [function.file]: failed to open stream: No such file or directory in /path/to/your/docroot/test.php on line 3

Now the proper thing to do of course would be to verify up front that the file exists and is readable with a call to is_readable() or something similar, but imagine this is a case where there is no way to determine ahead of time if a warning or error will be generated (Derick mentions silencing network errors with stream_socket_client() as one example). In this case, you might be tempted to use the shut-up operator and depend on the return value as the one true way to see if something was succesful or not.

Now compare this with what languages like Python (for example) do, If you were to write similar code in Python:

fp = file("/tmp/file.txt")

If the file did not exist, you’ll get an IOError which, if left uncaught, will result in the following being written to standard error:

Traceback (most recent call last):
  File "test.py", line 1, in <module>
IOError: [Errno 2] No such file or directory: '/tmp/test.txt'

The difference here of course is that an IOError can be caught, ignored or whatever best suits your needs. It’s a part of the language, the API is not just spewing out garbage to standard output or standard error. More importantly, having a function (or technically a constructor) like file() throw an exception follows a consistent design philosophy whereas PHP’s error system always leaves me guessing or consulting the docs.

I guess what I’m saying is that I think the shut-up operator is just one of those signs that PHP is suffering from some serious cruft and I don’t think those kinds of things bode well for a language.

• Pricing the Macbook Air so high with such low specs.
• Releasing an pitiful update to the air along with a nice $100 price increase.
• Doing away with the matte screen option.
• Pulling the remotes from being included with laptops (admittedly not a huge deal, but felt like salt on a wound).

Is it just me or is Apple becoming a little too arrogant? Anyway, I know Lenovo won’t be saints either, but at least in the non-Mac OS X world I can easily switch vendors down the road if I ever need to.

Copy on Write

In an effort to save CPU cycles, PHP uses an optimization strategy called “Copy on Write”. Basically what this means is that variable data isn’t copied until it needs to be. Using an example similar to the one found in the book:

$a = 50;
$b = $a;
$b += 5;

At the first line, the variable $a is created and memory is allocated for it. When we set $b to equal $a however, you might think that the data in $a is copied to $b. PHP doesn’t actually copy the data until the 3rd line when $b is incremented by 5. The value in this is that data is not copied unnecessarily. If, for some reason, we took out the 3rd line and $b was never modified after the initial assignment, the data would actually never have to be copied.

Return Value Used?

The second, admittedly more surprising thing I learned was that PHP provides internal functions a parameter called return_value_used whose value can be inspected to determine whether the return value being prepared by the function is actually being saved or not. Imagine you have a function that does some heavy crunching to compute a return value, and a caller (for some reason beyond us) does this:

<?php
...
myextension_compute_something();
...
?>

In other words, they call the function but don’t store the return value. Well, being a thoughtful internal function author, you can check to see that return_value_used evaluates to false and just skip doing any work, saving CPU cycles and time, like so:

PHP_FUNCTION(myextension_compute_something)
{
    if (return_value_used) {
        // some fancy but expensive algorithm
        // ...
        RETURN_DOUBLE(some_value);
    } else {
        RETURN_NULL();
    }
}

Later on I attended “Tiery-Eyed”, a talk given by a Zend employee, Kevin Schroeder on … you guessed it, tiered application development. It was pretty decent, Kevin walked the audience through the creation of a micro-blogging application using a variety of different backend tiers. I left with an urge to create the smallest application I could think off with one SOAP backend, one XML-RPC backend and one REST backend.

The highlight of the day was Sara Goleman’s talk on PHP Extension Writing. This was the most in-depth of the talks I attended and despite a few technical problems, the talk went smoothly. It was pretty broad but still managed to be quite inspiring.

The day ended with a reception in the exhibit hall. Free drinks and food is never a bad way to end a day…

So far I’m pretty impressed. I attended the PHP Developer Best Practices tutorial in the morning and the Quality Assurance in PHP Projects tutorial in the afternoon.

The Best Practices tutorial was a little broad and most of it was focused on topics that were pretty common / basic. I’m not sure exactly what I wanted to get out of it, but for somebody who already uses an SCM system, who already tests (although not as much as I should) and writes api documentation it wasn’t the most informative tutorial.

Sebastian Bergmann’s QA tutorial was excellent. Of course, as the primary author of PHPUnit, I assumed Sebastian would know what he was talking about and I was right. He offered a really good, in depth look at PHPUnit and covered some of the newer features. He also covered Selenium and specifically Selenium RC in quite a bit of detail.

Looking forward to more sessions… the day of tutorials was a great start, can’t wait to see what the conference proper has to offer.

If you’re familiar with frameworks like Ruby on Rails or Symfony however, you may notice that YAML support is missing. This is mostly because there is no one YAML parsing library for PHP. If you are willing to introduce another dependency to your application however, there is a really easy way to use Spyc to bridge YAML and Zend_Config. One of the nice things about the Zend_Config component is that it can take data right out of a PHP array (as opposed to an XML or INI file). This gives us quite a lot of flexibility, especially considering that Spyc returns parsed YAML data as a PHP array. Armed with this knowledge, the solution becomes really, really simple:

<?php
require_once 'Zend/Config.php';
require_once 'spyc.php';
 
$configFile = "config.yml";
$config = new Zend_Config(Spyc::YAMLLoad($confFile));
?>

Remarkably simple isn’t it? Now, given the YAML config file:

 webhost: www.example.com
 database: 
     adapter: pdo_mysql
     host: db.example.com
     username: dbuser
     password: secret
     dbname: mydatabase

The above PHP code will create a config object that can then be used like this:

<?php
print $config->webhost;        // prints 'www.example.com'
print $config->database->host; // prints 'db.example.com'
?>