Then I came across Pimple, which is a wonderfully simple solution to the problem.  The only thing about it is that I hate its array-oriented interface.  Something about $container['session_storage'] rubs me the wrong way.  So I decided to implement Pimple in a more object-oriented way, and what I came up with was Zit.

Zit works almost identically to Pimple, but with an object-oriented interface.  I think it’s easier to show than tell, so let’s start with a code example:

// Include and instantiate Zit
require_once '/path/to/lib/Zit/Container.php';
$c = new \Zit\Container();

// Set config parameters
$c->setParam('db_user', 'username');
$c->setParam('db_pass', 'password');
$c->setParam('db_host', 'localhost');
$c->setParam('db_name', 'test');

// Set up objects
$c->set('db', function($c) {
  $db = $c->getDbName();
  $host = $c->getDbHost();
  $user = $c->getDbUser();
  $pass = $c->getDbPass();
  $dsn = sprintf('mysql:dbname=%s;host=%s', $db, $host);
  return new PDO($dsn, $user, $pass);
});
$c->setUser(function($c, $id)) {
    $user = new User($id);
    $user->setDb($c->getDb());
    return $user;
});

// Use container
$user1 = $c->getUser(1);
$sameUser = $c->getUser(1);
$newUser = $c->newUser(1);
$user2 = $c->getUser(2);

Some comments about the code:

• The setParam() method is used for any non-object, so if you want to store scalars or an array, you use this method.
• All object instantiation functions are passed an instance of the Container as their first parameter.  That way all functions have access to other objects and parameters in the container.
• Zit automatically translates underscores to camel case depending on whether you’re using a string or a method to access that object/parameter.
• Zit is quite flexible in its interface.  For example, if you compare line 12 to line 20, you’ll see that you can set objects in a few different ways: set(‘db’, …), setDb(…) or set_db(…) all work exactly the same.  This means you can use Zit however you like (or according to the coding standards of the project you’re working on).
• By default, Zit shares object instances.  $user1 from line 27 is the exact same object as $sameUser on line 28 ($user1 === $sameUser).  If you want to create a new instance of an object, use the “new” methods.  Note: because “new” is a reserved keyword, there is no new() method on the Zit container object.  Instead, this method is called fresh().  This means that new objects can be created with any of the following methods:
• fresh(‘user’, …)
• freshUser(…)
• fresh_user(…)
• newUser(…)
• new_user(…)
• But not: new(‘user’, …)
• Instantiation methods can be passed parameters, which is helpful if you need to pass those parameters on to the object’s constructor, or the the constructor of one of the object’s dependencies.

As you can see, Zit does its very best to provide all the functionality and flexibility that you need without going overboard.  It acts almost exactly like Pimple, except for 3 important distinctions:

1. It has an object-oriented interface rather than an array-oriented one
2. All objects are shared by default
3. Objects can be passed constructor/instantiation parameters

This is the first release of Zit.  The unit tests cover most scenarios, so it should be fairly safe to use, but it hasn’t been used in production yet (I’m using it in two projects that will go into production shortly, though).

Download the latest release

Or, view on GitHub

I came up with a great tee shirt idea.  I’m going to print a few.  You can buy one if you want.

The modulo operation essentially calculates the remainder of a division.  For example:

5 % 4 = 1

What’s very useful, is that you can take any number, and easily group it into any size group.  For example, if you needed to separate 6 items into 3 groups (OK—obviously you would do this differently, but it’s just for demonstration), you can do the following:

1 % 3 = 1
2 % 3 = 2
3 % 3 = 0
4 % 3 = 1
5 % 3 = 2
6 % 3 = 0

Now your numbers are in group 0, 1, or 2.  This gets much more useful when you think about how almost all RDBMS tables have a numeric primary key value.  Need to split all the users in your system into 10 batches?  Just calculate the user ID % 10 and you have all your users evenly (or, evenly enough) split.

This is a great way to implement sharding.  For example, WordPress 3.0 and higher support multiple sites running on the same codebase. It does this by creating special tables for each site, in the format of PREFIX + ID + TABLE NAME (so a database might look like wp_322_posts).  Well, when you have a thousand sites, each with 10 or more tables, you start running into trouble keeping them all in one database.  That’s where the modulo operator comes into play:

function db_callback($query, &$wpdb) {
	// $wpdb->base_prefix = 'wp_';
	// $wpdb->table = 'wp_322_posts';
	if (preg_match("/^{$wpdb->base_prefix}(\d+)_/i", $wpdb->table, $matches)) {
		// Pretend we have 3 databases
		// Will return 'database0', 'database1' or 'database2'
		return 'database' . ($matches[1] % 3);
	}
}

Another recent way I’ve used the modulo operator is sending out a weekly batch email to a large number of users.  In this case, I had hundreds of thousands of records to read, parse, and then send out an email based on the results.  Rather than do all 600,000 records at once, I split them up into 7 batches, based on day.  Here’s a simplified version of that query:

$sql = 'SELECT * FROM table
        WHERE user_id MOD 7 = ' . date('w');

Then I just set up the script to run daily through my crontab, and each user gets their email once a week, on the same day each week.  Alternately, you could send the message every hour to break it into 168 separate blocks throughout the week:

$sql = 'SELECT * FROM table
        WHERE user_id MOD 168 = ' . ((date('w') * 24) + date('H'));

It’s something that you don’t necessarily use often, but it’s very handy to have in your repertoire.

Cross-browser kerning-pairs & ligatures

And thought, “there’s gotta be an extension for that.”  Well, looks like there isn’t… so I made one:

Enjoy!

Wouldn’t it be nice if instead it looked like:

I’ve developed a (very) simple CSS file that styles links (and <button> elements) to look like native Safari toolbar items.  Download it now.

I want to say thanks to everyone who came out to the event! Also thanks to Joe Kaufman and Rob Hall for their fantastic presentations. We ran a little long and some folks had to leave before seeing Joe’s demo, so I just wanted to mention it here. For those of you who haven’t see it, GameSalad is pretty magical, and the demo definitely got more than one round of applause. Check it out (take a minute or two to watch the demo video—you’ll be blown away). You should also check out Rob’s PhillyGeekCentral app (written entirely in ActionScript 3 and compiled using Flash CS5).

Beyond that I just wanted to open up the comments for any feedback anyone might have on my talk, and to answer any questions that came up after we finished with Q&A. Feedback is particularly useful to me (and don’t be afraid to criticize—I can handle it) because I haven’t done much presenting and am still trying to get a sense for what works and what doesn’t.

There are two things that came up in private after the presentation that I think are worth sharing with everyone:

1. A couple people asked me about styling applications written for PhoneGap or Titanium. In the case of PhoneGap you don’t really get any built-in styles because it’s really just a web page running in a chrome-less browser. That means if you want to mimic the iPhone’s UI or create something similar, you have to do it all with CSS and JavaScript. Luckily there are a number of frameworks out there that do that for you, and when I get my slides online I’ll have a bunch of resources to start with. For right now I would recommend checking out XUI and jQTouch. These tools help you get a nice mobile UI up and running in no time. (It’s worth mentioning that in the case of Titanium this is less of an issue because you can use native components.)
2. I also noticed that the question of local storage came up a few times, and I just wanted to clarify there. Mobile Web Apps, PhoneGap Apps and Titanium Apps all have access to local storage. Even in a web app, you can save settings to the phone that will still be there when the user closes Mobile Safari and reopens it. You don’t have to talk to a web server at all if you don’t want to.

Finally, I wanted to talk a little about choosing whether you should build a web app or a native app. This is something I’ve been thinking about a lot and just didn’t have time to talk about last night. Right now everyone is trying to get on Apple’s App Store. It seems like most major web sites either have native apps on the store already, or are planning to do so soon. But in the case of services that aren’t used daily (or at least weekly) I don’t think this makes any sense. There’s a reason that Kayak.com (thanks to Andy Mroczkowski for this perfect example) is a web site and not a program that you download for your computer; For services that you only use time-to-time, it doesn’t make any sense to use a dedicated application. So why would you want a dedicated application on your phone? Well, you probably don’t. But because everyone needs to be on the App Store today, that’s where you’ll find Kayak’s best mobile interactions.

That’s not to say that there aren’t a ton of instances where a native app wouldn’t be worth it. I just think that far too many people are trying to develop native apps when they really aught to be working on great mobile web sites (or web apps). Just like anything else, think about your users and their needs and choose the best option for them, even if it’s not 100% buzzword friendly.

Well, this post came out a lot longer than anticipated. If you can’t tell, mobile development is a topic that I’m happy to talk about, so if you have question feel free to ask.

Here are some of the resources I mentioned for mobile app development:

• Safari Mobile Web Programming
• Viewport Meta Element
• CSS3 Media Queries
• PhoneGap
• Titanium Mobile
• Apple iPhone Dev Center
• W3C Geolocation API
• Offline Storage & Caching
• CSS3 Transitions

find / -type f -size +20000k -exec ls -la {} \; | sort +4 -nr | awk '{ printf "%-20s %s\n", $5/1048576, $9 }' > bigfiles.txt &

You can exclude a path by adding a little more to the command. The following will do the same as above but exclude the /backup directory:

find / -path '/backup' -prune -o -type f -size +20000k -exec ls -la {} \; | sort +4 -nr | awk '{ printf "%-20s %s\n", $5/1048576, $9 }' > bigfiles.txt &

You can also change the 20000k to whatever you want the smallest files to be.

It’s a fantastic little command and I just thought I’d share it with the world.

“I’m not going to do [a] because I need to get [b] right first.”

I, like most people, am a master of procrastination.  I clean my desk, file my e-mail, make a few phone calls, write a blog entry, etc, just to avoid whatever it is I should be doing.  Recently I discovered a new*, and troubling form of procrastination: “getting it right.”

For the past few months I’ve been working on a major restructuring of one of InterNACHI‘s core web systems.  Lately I’ve found myself not moving forward because I want to make sure the architecture is right, or I have some concerns about how certain decisions will affect search rankings, or I’m not sure if it will perform well, etc.  So instead of sitting down and finishing the project, I pull out a pad of paper and start outlining or graphing or whatever it is I convince myself I need to be doing.

Now that’s not to say that preparation isn’t important, but I’m starting to think that the agile guys got it right: build early and build often.  And I realize that this is nothing new.  Heck, nearly all of “web 2.0″ is built on the constant “beta” principal.  But I also know that as businesses grow, there’s a tendency to add unnecessary formality to otherwise simple things; at least I know that’s what we’ve done.  It’s almost like you get into this mentality of “this is how the big guys do it,” when it’s the little guys who are more compelling and innovative.

And on top of it all, “getting it right” is just a fiction.  There’s no such thing.  Today’s “right” is tomorrow’s “what was I thinking?”  I might as well get something “close” today, and “better” tomorrow.

So where is this post going?  I’m not really sure… I think I’m done, but I really don’t feel like getting back to work

So what do you guys think?  Am I the only one who procrastinates this way, or is this a common thing?

* By new, I mean newly identified.  I’ve been doing this for years.

Oh man… here goes.

/**
 * Determines a URL's associated Pavatar (http://pavatar.com/)
 * Returns a URL on success, FALSE on failure
 * Does NOT verify that the URL is a valid image
 *
 * @author Chris Morrell (http://cmorrell.com)
 * @param string $url
 * @return mixed
 */
function getPavatar($url)
{
    // Grab Data
    $curl = curl_init($url);
    curl_setopt($curl, CURLOPT_HEADER, 1);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
    $page = curl_exec($curl);
    curl_close($curl);

    // On Fail
    if (!$page)
    {
        return false;
    }

    // X-Pavatar Header Method
    elseif (preg_match('/X-Pavatar:\s*(.*?)(\s|\n)/i', $page, $matches))
    {
        return $matches[1];
    }

    // <link> Method
    elseif (preg_match('/<link.*?rel="pavatar".*?>/i', $page, $matches))
    {
        preg_match('/href="(.*?)"/i', $matches[0], $matches);
        return $matches[1];
    }

    // Default URL Method
    else
    {
        $info = parse_url($url);
        return "{$info['scheme']}://{$info['host']}/pavatar.png";
    }
}

Usage:

$pavatar = getPavatar('http://cmorrell.com');

Enjoy!