session_id('stash-stuff-here');
session_start();
$_SESSION['stuff'] = $w00tz;

(Another quick and dirty approach would be serializing an array into a local file… oh, wait, I just recreated the default PHP session handler. )

Credit where credit is due: this was inspired by other people’s work with other unit testing frameworks.

Anyways, the short screencast in my update last night has already generated some interest, so I thought I’d get this out on the web for perhaps wider exposure.

Coming soon: continuous integration on your desktop for your PHPUnit projects.

Anyways, a few days ago a coworker mentioned something to me about duck typing, and I again decided to shirk my responsibilities and experiment. The basic idea is to stand typing on its head and have an imperative system rather than declarative — as they say, “if it walks like a duck, and quacks like a duck, it must be a duck.”

So how does that translate to actual code? Well, normally a class exports all its interfaces in a static list defined when the class is written. But sometimes it’d be nice to ask for a class that has all the features necessary to implement a given interface even if the class wasn’t declared as an implementor.

Since there’s no language support for this in PHP, my (proof-of-concept) solution relies exclusively on the Reflection library to validate method existence and signatures.

Time for an example.

class B
{
  public function woot($a)
  {
    echo 'haha';
  }
}

interface A
{
  public function woot($a);
}

var_dump(Goose::isA('A', new B()));

Notice that B never declares that it’s going to implement the interface A. Yet Goose::isA will return TRUE, because, while it’s not declared as such, B does satisfy all the requirements of the interface.

For instance, if I see another line of code that does this:

$foo = isset($foo) ? $foo : 'default value';

I think I’ll kill someone.

Let me clear something up for you: using the ternary operator does not make you cool. However, assigning a variable to itself makes you very uncool.

if (!isset($foo)) $foo = 'default value';

Now why is that so hard to write?

Apparently, AOL is finally opening AIM up really wide. They’re talking about full protocol documentation (that’s the “oscar” protocol, not the crappy TOC one), letting people use their own AIM libraries, and full access to all the functionality (voice, video, filesharing, etc.) — as far as I know, this stuff has never been available before.

I also noticed that you can now convert any AIM screen name into a “bot”: the various rate limits are removed (or heightened, at the very least), you can’t be warned, and are allowed to be added to more people’s buddy lists. In return, you can’t initiate conversations.

You know what this means.

The screen name crabbychild has been successfully converted to an AIM® Bot.

Maybe some example code will explain it better. Let’s say I have a class that’s a counter, just wrapping an integer.

<?php
class Counter
{
    protected $count = 0;

    public function increment()
    {
        $this->count++;
    }

    public function getCount()
    {
        return $this->count;
    }
}

?>

And now, for some reason, I want to add two counters together. I add a method to Counter named add() that accepts another instance of Counter. But rather than calling increment() $count times, I can simply write:

    public function add(Counter $c)
    {
        $this->count += $c->count;
    }

Blindingly simple, really, but something I often forget about.

Tonight, mostly as an exercise in futility, I began looking at some of the foreign keys stored in the gargantuan tables. One of them in particular links to a table that currently contains (oddly enough) 256 rows. It grows very, very slowly. Currently the column is a long integer: 4 bytes. Imagine for a minute that we replaced that with what MySQL calls a small integer, or 2 bytes. Last month’s table was in the neighborhood of 900,000,000 rows, times 2, divided by 1024… That’s something just shy of 2 GIGAbytes that we’ve saved. (Never mind that there are about 4 other foreign keys this could also be applied to).

Every byte adds up, folks. Save ‘em while you can.

(Some might call this inconvenient math. I’m not quite that unscrupulous.)

Fortunately (and if you follow the PHP world, you’ve probably heard about this), Studio is receiving competent competition in the open-source world from the Eclipse platform in the guise of the PHP Developer Tools, or PDT. (And that’s competition in a very liberal sense of the word, since Zend is actually backing PDT — so they can rip it of– base future versions of Zend Studio on it.)

Anyways, the real goal here was just to talk about a quick PDT tip (now that I’ve switched), not rant and rave about how Zend seems to have a knack for positioning themselves in the middle of hugely conflicting interests.

The tip: Most people know that you can Ctrl+Click “into” a function call. What I didn’t know is that you can also Ctrl+Hover to get a tooltip containing the first ~10 lines of the function.

This can be immensely useful when you’re just trying to figure out what a piece of code does, without completely losing your train of thought and switching contexts.