First things first
The source code that I based this post on is available on GitHub.

Generating URL shortener keys
Understanding how to properly generate a key is the most important part of a url shortener. If you get this wrong, you’ll find out that your urls aren’t very short and you can’t go back and fix it. The sequence can be thought of a base 62 sequence (using a-zA-Z0-9). Following this logic, the 1,000,000th sequence would be emjb. Expanding that out would look like the following equation.

// e=4
// m=12
// j=9
// b=1
// 1*62^0 + 9*62^1 + 12*62^2 + 4*62^3 = 999,999

I deviated from this logic when writing the getNextKey function. Nonetheless, it’s good to understand the compactness of the keys. The getNextKey takes a key and calculates the next one. If a key isn’t passed in then it defaults to a.

// don't use globals, put these in a class
$range = array_merge(range('a','z'), range('A','Z'), range(0,9));
$trans = array_flip($range);

function getLastKey()
{
  // fetch last key and return
  return 'a';
}

function getNextKey($key = null, $tail = '')
{
  global $range, $trans; // bad
  if($key === null)
    $key = getLastKey();
  if(empty($key))
    return "a{$tail}";

  $keylen = strlen($key);
  $lastChar = $key[$keylen-1];

  if($lastChar != '9')
    return substr($key, 0, ($keylen-1)) . $range[$trans[$lastChar]+1] . $tail;
  else
    return getNextKey(substr($key, 0, -1), "a{$tail}");
}

Redirecting shortened requests
When a request comes in you need to yank the key from the url, look up its long url and perform the redirect. A sample database schema for storing URLs would look like this:

CREATE TABLE `url_redirect` (
  `ur_id` int(10) unsigned NOT NULL auto_increment,
  `ur_key` varbinary(255) NOT NULL,
  `ur_url` varchar(255) NOT NULL,
  `ur_dateCreated` int(10) unsigned NOT NULL,
  PRIMARY KEY  (`ur_id`),
  UNIQUE KEY `ur_key` (`ur_key`)
);

The next piece is to set Apache up to handle all requests. Place the following, which uses mod_rewrite, into your VirtualHost definition.

RewriteEngine on
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*) /index.php?__key__=$1 [L,QSA]

This makes sure all requests are handled by index.php.

$key = addslashes(substr($_GET['__key__'], 1));
$dbh = mysql_connect('localhost', 'root', ''); // bad
$redirect = mysql_fetch_assoc(mysql_query("SELECT ur_id, ur_url FROM url_redirect WHERE ur_key='{$key}'"));

if(!$redirect)
  throw new Exception("Did not find redirect key {$_SERVER['REQUEST_URI']} in database");

header('HTTP/1.1 301 Moved Permanently');
header("Location: {$redirect['ur_url']}");

Wrapping it up
These are the basics of setting up a URL shortener. Their value is a topic of much debate. I personally feel that they do more harm than good. Regardless, they’re here to stay.

You can download these samples on GitHub (http://github.com/jmathai/playground/tree/master).

Experience how it works
I’ve set up a basic example on this site. Try it out here. The files used in this example are available for download and should work on your server if you follow the steps.

Getting up to date
If you experience any problems then make sure you are using the latest version of the code. It’s available on Github.

Setting up your application on Twitter
The first step is to set up your application on Twitter. You can add an application on Twitters OAuth clients page. Click on register a new application and fill out all the fields. The two important fields are:
* Callback URL: The location of confirm.php on your server (http://yourdomain.com/confirm.php)
* User Twitter for login: Check this!
Once you’ve created your application you will need to copy and paste your consumer key and secret into secret.php.

Seeing it all in action
That’s it. Browse to start.php on your server and follow the flow. You’ll be asked to log in to twitter if you’re not already. Once you log in, Twitter will confirm that you want to allow your application access to your account. Clicking confirm will take you back to your callback url along with a request token. You’ll exchange your request token for an access token which you can use to authenticate as yourself (or whoever is going through flow). For the sake of this exercise we are saving the access token to a cookie. We use the access token to retrieve your profile and place a link to another page. This other page will use the access token from your cookie and get a listing of all your friends.

The beauty of this is that once a user allows your application access to their account they don’t have to do it again. This means that the next time they visit your site and click on the link to sign in with twitter, it will immediately redirect them to your callback page with the request token. It’s all very seamless because from the user’s perspective if they are logged into Twitter they are logged into your site. Very cool.

A look at the code
Every file loads in the dependencies. These are the includes at the top of each page.

include 'EpiCurl.php';
include 'EpiOAuth.php';
include 'EpiTwitter.php';
include 'secret.php';

Anytime you want to make requests to Twitter you need to instantiate the EpiTwitter class. The constructor takes a minimum of two parameters: your consumer key and consumer secret.

$twitterObj = new EpiTwitter($consumer_key, $consumer_secret);

To obtain the authenticate url which starts the flow you simply call the correct function.

$authenticateUrl = $twitterObj->getAuthenticateUrl();

Once the user authenticates with Twitter they are redirected back to your callback url along with a request token. We need to exchange the request token for an access token. For simplicity we will save the access token to a cookie so we can make subsequent calls. On this page we will use the setToken method to set the access token and secret. As we will see on the next page, these can be passed in as parameters to the constructor as well.

$twitterObj->setToken($_GET['oauth_token']);
$token = $twitterObj->getAccessToken();
$twitterObj->setToken($token->oauth_token, $token->oauth_token_secret);
setcookie('oauth_token', $token->oauth_token);
setcookie('oauth_token_secret', $token->oauth_token_secret);

Since we saved the access token in a cookie we can make calls to twitter on behalf of the user for as long as the cookies are valid.

$twitterObj = new EpiTwitter($consumer_key, $consumer_secret,
    $_COOKIE['oauth_token'], $_COOKIE['oauth_token_secret']);

$twitterInfo= $twitterObj->get_statusesFriends();
try{
  foreach($twitterInfo as $friend) {
    echo $friend->screen_name;
  }
}catch(EpiTwitterException $e){
  echo $e->getMessage();
}

Update: If you don’t access any of the response variables then there is no guarantee that the call completes. This should also be done in a try/catch block since a non-200 response will throw an exception.

That’s all! If you’re still interested in learning more about OAuth then the following links are invaluable.

• http://wiki.github.com/jmathai/twitter-async
• http://apiwiki.twitter.com/Twitter-API-Documentation
• http://oauth.net/core/1.0/
• http://www.hueniverse.com/hueniverse/2008/10/beginners-gui-1.html

A new project I’m working on integrates closely with Twitter. As a result, I become a lot more familiar with OAuth than I care to. Many developers want to be able to speak the OAuth protocol without having to know the fine details. I am deviating from the normal order by starting with an example and explaining it afterwards. If you are interested in using “Sign in with Twitter” then read my other blog post.

A simple example
To follow the example, you’ll need to download these files and have a web server set up. I use my laptop but you can also use a webhost if you’d like. Head over to Twitter and set up an application. The last two fields are important. The callback url will need to redirect to your web server at a location where you will be uploading some files. Assuming you’re going to upload into your web root, the callback url would be something like http://yourdomain.com/confirm.php. You’ll also need to make sure you select “Read & Write” access.

Once you click save, you will be presented with some information. Download the php files for this example and open secret.php. Enter your consumer key and consumer secret in the appropriate areas. Save and upload to your webserver.

Open a browser to your webserver’s start.php file you just uploaded. You’ll see a link to authorize with Twitter. Clicking on that link will take you to Twitter’s site and ask you to log in if you’re not already.

Once you click Allow you’ll be redirected back to your site with a custom greeting pulled straight from Twitter. It doesn’t get much easier than that. From here on out you can use the token and secret provided by Twitter to access the API on behalf of the user who authorized you. Now, the details.

Why use OAuth…the benefits
OAuth is “an open protocol to allow secure API authorization in a simple and standard method from desktop and web applications.” What’s that mean? In short, it means that a user of your service can provide you limited access to a third party account of theirs. OAuth is often described as a valet key that your users can give you to access their accounts on other services. For example, a user using Flickr (the service provider) would provide Snapfish (the consumer) with read only access to their Flickr account. This lets Snapfish access photos in the user’s Flickr account so they can order prints.

It’s all in the tokens
How does this happen without asking the user to give up their Flickr password? The flow would start by Snapfish obtaining a consumer key and secret and using them to generate an authorization link to Flickr. Once the user follows the authorization link, they are asked to log in on Flickr’s site. Once logged in they can choose to grant Snapfish access to their Flickr account. Flickr then marks the request token as having been authorized by the user. Snapfish uses the request token to obtain an access token which can be used by to make requests to Flickr on behalf of the user. This diagram may help visualize it easier. C = Consumer, SP = Service Provider

Let’s dive in
I had several goals in writing a PHP client for OAuth and Twitter.

• The two should be decoupled, making it easier to add other OAuth services
• Reuse the asynchronous/non-blocking curl library
• Expose methods which would enable OAuth requests in less than 4 lines of code

Generating a valid OAuth request
It turns out that generating an OAuth request is very simple but debugging it is a pain. Every OAuth request contains certain parameters. These include:

• oauth_consumer_key
• oauth_token
• oauth_nonce
• oauth_timestamp
• oauth_signature method
• oauth_version
• oauth_signature

These can be passed in as GET or POST parameters or in the Authorization header. You’ll most likely be passing in other additional parameters based on the API you’re accessing. I won’t get into the details of what these parameters represent in this blog post but it’s good information to know.

A look inside EpiOAuth
EpiOAuth initializes an instance of the EpiCurl object in its constructor. Since EpiCurl is not included, you’ll want to make sure you’ve made it available ahead of time. There are several methods which you’ll need to know about.

• getAccessToken
• getAuthorizationLink
• getRequestToken

If you reference the diagram above, then these should be self explanatory. There are several other helper methods which act more behind the scenes but play an important role.

• generateSignature
• generateNonce
• httpRequest
• prepareParameters
• signString

These do all the magic to turn an otherwise normal request into a valid OAuth one.

How EpiTwitter extends EpiOAuth
Per my original goal, the Twitter class should contain a very minimal set of functions which call specific endpoints. These methods are self explanatory if you look at them as well. I did, however, want to make it easy to use the class in an asynchronous manner since the underlying http library I was using supports it. This led me to create an EpiTwitterJson. When you make a request you’ll receive an instance of the EpiTwitterJson object without blocking for a response from the Twitter API. You can at any point access individual elements in the response as a member variable. Accessing the member variable with return the value and block if needed.

Wrapping it up
This should help get you up and running. The code provided is very much under construction. I would greatly appreciate contributions to make it better. You can watch me on GitHub or fork the project.

If you’re interested in learning more about OAuth then there’s a great set of articles located at http://oauth.net/documentation/getting-started.

Comments are closed on this post. If you find a bug, please open an issue on GitHub.

Setting up the rsync
The rsync command is fairly straightforward but we’ll be doing some slight modifications to it. We’ll create a shell script so that it’s easy to update the files as needed.

user# echo '#!/bin/sh

rsync -avzC --timeout=600 --delete --delete-after \
      --include="manual/en/" --include="manual/en/**" --exclude="manual/**" --exclude="distributions/manual/**" \
      --exclude="distributions/**" \
      rsync.php.net::phpweb /path/to/document/root' > php-net-mirror.sh
user# chmod u+x php-net-mirror.sh
user# sudo su
root# echo 'php' >> /etc/hosts
root# exit
user# ./php-net-mirror.sh

You’ll notice that we added an exclusion list for distributions/**. This is so you won’t be sitting and waiting for 10+ distributions of PHP source to download to your laptop. You’ll also need to replace /path/to/document/root to any location that you have write permission to. We’ll later use this in our Apache vhost definition. I put it something inside of my home directory in a subdirectory named php.net. Don’t forget to set the permissions on the shell script so that you can execute it.

NOTE: If you’re using windows then you can use cwRsync available on sourceforge. Thanks to Ronnie and rui for the tips in the comments.

In order to access it from your browser you’ll need to decide what hostname to use. I chose php so that I can quickly browse to http://php/mysql_connect to view the documentation for that function. You can choose whatever you want, just substitute that when echo’ing into the hosts file.

The final step is to run the script. You’ll see the full list of files as they download. Updates should be much faster since you’ll only be pulling down files which have been modified.

Setting up Apache
Create a new Apache virtual host using the following definition.

<VirtualHost *>
     <Directory "/path/to/document/root">
          # Do not display directory listings if index is not present,
          # and do not try to match filenames if extension is omitted
          Options -Indexes -MultiViews
     </Directory>

     ServerName php
     ServerAdmin yourname@example.com

     # Webroot of PHP mirror site
     DocumentRoot /path/to/document/root

     # Log server activity
     ErrorLog logs/error_log
     TransferLog logs/access_log

     # Set directory index
     DirectoryIndex index.php index.html

     # Handle errors with local error handler script
     ErrorDocument 401 /error.php
     ErrorDocument 403 /error.php
     ErrorDocument 404 /error.php

     # Add types not specified by Apache by default
     AddType application/octet-stream .chm .bz2 .tgz .msi
     AddType application/x-pilot .prc .pdb 

     # Set mirror's preferred language here
     SetEnv MIRROR_LANGUAGE "en"

     # Turn spelling support off (which would break URL shortcuts)
     <IfModule mod_speling.c>
       CheckSpelling Off
     </IfModule>
</VirtualHost>

You’ll need to update the path to your document root on lines 2 and 12. This should match the path you specified in the shell script above. Line 8 also needs to be updated with the hostname you specified earlier to access the site with.

Fire up the site
That’s all! Execute the command you use to restart Apache. If you’re using OSX with MacPorts then you can execute the following commands.

user# sudo /opt/local/apache2/bin/apachectl restart
user# open -a Safari "http://php/mysql_connect"

Viola!

Memcached: It’s Comcastic!
There’s no doubt that memcached is wicked fast. It’s used heavily here at Yahoo! and Facebook uses it extensively as well. An important feature which makes memcached both scalable yet at the same time more expensive (when compared to local memory) is that it’s on the network. This ads a bit of overhead which can generally be avoided with some simple caching of memcached.

A quick example
Every scenario is different, but let’s assume that you use memcached for your session store (it may have MySql behind it but that’s irrelevant). It’s so easy to get a common piece of information like a username.

$memcachedObj->get("username-{$_COOKIE['userId']}");

Let’s say you do that 5 times on a page. Without realizing it, you’ve made 5 network calls to get the username from your ultra speedy cache. That doesn’t sound like an efficient cache store to me.

YAC (Yet Another Cache)?
I’m not suggesting you get data from memcached and then store it in a persistent local memory store. You could do that but a simple alternative is to just store it for the current process and dispose of it along with all the other data that goes along with it.

function connectToCache(){
  static $memcachedObj;
  if(!$memcachedObj)
    $memcachedObj = memcache_connect('remote_host', 11211);

  return $memcachedObj;
}

function getFromCache($key){
  static $cache;
  if(!$cache[$key]){
    $memcachedObj = connectToCache();
    $cache[$key] = $memcachedObj->get($key);
  }

  return $cache[$key];
}

echo getFromCache("username-{$_COOKIE['userId']}");

Wrapping it up
While the above code probably works (I didn’t actually test it), you really want to wrap this up in a nice and tiny caching class. Fortunately, I’ve gone ahead and done that for you. As part of the EpiCode PHP framework I’ve written a generic caching component with plugins for both APC and memcached.

require_once 'EpiCache.php';
$cache = EpiCache::getInstance(EpiCache::MEMCACHED);
echo $cache->get("username-{$_COOKIE['userId']}");
// or a one liner
// EpiCache::getInstance(EpiCache::MEMCACHED)->get("username-{$_COOKIE['userId']}");

Feedback
If you’ve used memcached in clever ways then post in the comments. I would like to continually improve the performance of various caches and this is just one of many methods.

So what’s the problem?
No problem. PHP does implicit type conversion when comparing two values. The string facebook when converted to an integer becomes 0. So when PHP does the comparison it’s true.

var_dump((0 == 'facebook')); // true
var_dump((1=='1 is the loneliest number')); // true

Generally speaking you’ll probably want to do a strict comparison when using PHP’s array search functions. Unfortunately, the default behavior is to do loose comparisons. Make sure you pass in the extra argument in order to force a strict check.

May the source be with you
The C source for the function that winds up being called helped us location the problem. Note the last argument behavior.

static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ */
{
        zval *value,                            /* value to check for */
                 *array,                                /* array to check in */
                 **entry,                               /* pointer to array entry */
                  res;                                  /* comparison result */
        HashPosition pos;                       /* hash iterator */
        zend_bool strict = 0;           /* strict comparison or not */
        ulong num_key;
        uint str_key_len;
        char *string_key;
        int (*is_equal_func)(zval *, zval *, zval * TSRMLS_DC) = is_equal_function;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "za|b", &value, &array, &strict) == FAILURE) {
                return;
        }

        if (strict) {
                is_equal_func = is_identical_function;
        }

        zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
        while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&entry, &pos) == SUCCESS) {
                is_equal_func(&res, value, *entry TSRMLS_CC);
                if (Z_LVAL(res)) {
                        if (behavior == 0) {
                                RETURN_TRUE;
                        } else {
                                /* Return current key */
                                switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &str_key_len, &num_key, 0, &pos)) {
                                        case HASH_KEY_IS_STRING:
                                                RETURN_STRINGL(string_key, str_key_len - 1, 1);
                                                break;
                                        case HASH_KEY_IS_LONG:
                                                RETURN_LONG(num_key);
                                                break;
                                }
                        }
                }
                zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
        }

        RETURN_FALSE;
}

Currently, I use a Mac so I’ll go over how to set everything up using MacPorts. However, there are many packaged applications that let you get up and running with a web server, scripting language and database.

Installing MacPorts
MacPorts is great. It reminds me a lot of Gentoo’s portage which I love. To get started you’ll need to download the appropriate version of MacPorts here. Make sure you have XCode installed, else follow the instructions to install it. You can tell if you have XCode installed by doing the following in your terminal. You should se a similar output if XCode is installed.

jmathai@[~]: ls /Developer
About Xcode Tools.pdf Documentation         Extras                Icon?                 Makefiles             SDKs                  usr
Applications          Examples              Headers               Library               Private               Tools

Once you get MacPorts and XCode installed you can begin getting familiar with the port command. MacPorts has a subsystem you can use to quickly familiarize yourself with the options available to you. To enter the subsystem enter the following in your terminal.

Getting started with MacPorts
You’ll want to modify your executable path so you can easily access binaries installed by MacPorts. You’ll want to add export PATH=/opt/local/bin:/opt/local/sbin:$PATH somewhere in ~/.bashrc or ~/.bash_profile. Otherwise you’ll receive errors in the form -bash: port: command not found.

jmathai@[~]: which port
/opt/local/bin/port
jmathai@[~]: sudo port
MacPorts 1.600
Entering interactive mode... ("help" for help, "quit" to quit)
[Users/jmathai] >

Now you’re in the MacPort subsystem and can begin issuing commands.

[Users/jmathai] > help
...
Supported commands
------------------
activate, archive, build, cat, cd, checksum, clean, compact, configure,
contents, deactivate, dependents, deps, destroot, dir, distcheck, dmg,
dpkg, echo, ed, edit, exit, extract, fetch, file, gohome, help, info,
install, installed, lint, list, livecheck, location, mdmg, mirror, mpkg,
outdated, patch, pkg, provides, quit, rpm, search, selfupdate, srpm,
submit, sync, test, trace, unarchive, uncompact, uninstall, upgrade,
url, usage, variants, version, work
...

One of the first things you’ll want to do is to make sure MacPorts is up to date. Once you do that then go ahead and search for some common packages that you might want to install. For this example we’ll go with the traditional LAMP stack including Apache, PHP, MySql…excluding Linux of Course. We can search for apache, php and mysql.

[Users/jmathai] > selfupdate
MacPorts base version 1.600 installed
Downloaded MacPorts base version 1.600
The MacPorts installation is not outdated and so was not updated
selfupdate done!
[Users/jmathai] > search php5
...
php5                           www/php5       5.2.6        PHP: Hypertext Preprocessor
...
[Users/jmathai] > search apache2
...
apache2                        www/apache2    2.2.10       The extremely popular second version of the Apache http server
...
[Users/jmathai] > search mysql5
...
mysql5                         databases/mysql5 5.0.67       Multithreaded SQL database server
...
[Users/jmathai] >

Start installing packages with MacPorts
Ports have the notion of variants which is beyond the scope of this post but we’ll touch on the topic. To install php you can specify that you want it built with apache and myself. You can additionally specify that you want pear installed as well. We’ll install php5 with support for apache2 and mysql5. MacPorts will take care of the dependencies and install all the required packages.

[Users/jmathai] > install php5 +apache2 +mysql5

MacPorts downloads source tarballs and compiles them. This can take a long time, sometimes REALLY long. Be patient.

Understanding where MacPorts installs packages
MacPorts installs packages into /opt/local. For example, you’ll find your php.ini in /opt/local/etc/php.ini and your apache2 files in /opt/local/apache. Let’s verify that everything was installed successfully. Get back to your normal terminal prompt.

[Users/jmathai] > exit
Goodbye
jmathai@[~]: sudo /opt/local/apache2/bin/apachectl restart
jmathai@[~]: echo '<?php phpinfo(); ?>' | sudo tee /opt/local/apache2/htdocs/phpinfo.php
<?php phpinfo(); ?>
jmathai@[~]: open -a Safari "http://localhost/phpinfo.php"

Viola!
There’s plenty of information available on configuring apache and mysql. If you have any specific questions then post them in the comments and I’ll do my best to answer them.

Additional reading

• http://garrickvanburen.com/archive/how-to-install-macports-apache2-rails-mysql-mongrel-and-subversion-on-an-intel-mac
• http://badpopcorn.com/blog/2008/09/19/installing-mysql-with-macports-for-rails-on-leopard/
• http://www.virtualchaos.co.uk/blog/2008/08/23/installing-php5-apache2-using-macports-on-leopard/
• http://iparrizar.mnstate.edu/~juan/urania/2008/08/14/fixing-my-php-woes-with-macports/

• Create a Perl dictionary in Python.

Google (phone):

• What is a sticky bit?
• How do you display all available information for an inode?
• What is the default switch for kill?

Gaia Online (in person):

• Write pseudocode which determines if a move is legal in reversi.
• Write a regular expression to convert this UBB code into valid HTML: The dog [b]ran over [i]the street[/b] and said: [blockquote]i am a dog[/blockquote].
• Questions regarding what I did to help scale software at Photagious and ClearChannel.

Rearden Commerce (in person):

• What is the architecture where you currently work and what are some of the bottlenecks?
• How do you go about solving a performance problem?
• Can a computer process two things at the same time?
• How would you implement support for multiple languages in a web application?
• How would you remove all of the sequential characters from the following string: AADBDDDABDDEAAD?
• How would you speed up the performance of Javascript?
• How would you speed up the performance of CSS?

Yahoo! (in person):
Group 1

• What does the gnu top program do?
• What does the gnu find program do?
• What is the difference between a thread and a process?
• What version control software have you used?
• Why would you use git over subversion?
• What is a hash datatype?
• What is a super class or parent class?
• Explain prototype in Javascript.
• What character encoding does Javascript use?
• What methods are supported by HTTP?
• When wouldn’t you use an MD5 hash?
• How would you approach writing an similar hashing algorithm to MD5?
• What is a CSS sprite?

Group 2

• Given a 2 dimensional array write pseudocode which sorts the array by the 2nd dimension.
• How would you replicate the PHP extract function?

Group 3

• How would you efficiently pull out links to MP from an HTML file?
• Can you avoid cross site scripting (XSS) with ajax calls?  If so, how?

Group 4

• Given n points in the form (x1, y1, z1)…..(xn, yn, zn), find the k closest points to the origin.
• Given the same points as above, find the K closest points to each other.
• Given a url such as http://yahoo.com/foo/bar/../baz/./abc/foo/def/../ghi, determine the final directory being requested by parsing the string.
• Given the following set of numbers: 10, 7, 5, 8 find all pairs which add up to 15.

Once it was all said and done, we all ended up out here in sunny California.

Defining the goal
I wanted to be able to selectively publish photos from my Photagious account to Facebook.  I didn’t need any of the fancy Facebook application junk…I just wanted to make it easy to post photos from my Photagious account into my Facebook photos.  Turns out that it’s dead simple once you do a little bit of research.

Step number one
First, you need to get an application key and secret.  One way to do this by creating a new application.  Most of the information you’ll be asked for will be unused, so fill them in with whatever you’d like.  Just make sure to enable developers working on the application to install it.

Step number two
Second, you need to install the application.

Step number three (final)
Now, the code.  Basically, you generate the request with the required fields, generate the signature, append the file and send off the request.  For the sake of brevity, I’m pasting in the entire file here.

$key = 'your_key';
$sec = 'your_secret';
$ver = '1.0';
$cid = microtime(true);
$uid = 'BIGINT';
$file= '/path/to/your/file.jpg';

$args = array(
  'method' => 'photos.upload',
  'v' => $ver,
  'api_key' => $key,
  'uid' => $uid,
  'call_id' => $cid,
  'format' => 'XML'
);
signRequest($args, $sec);
$args[basename($file)] = '@' . realpath($file);

$ch = curl_init();
$url = 'http://api.facebook.com/restserver.php?method=photos.upload';
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $args);
$data = curl_exec($ch);

echo $data;

function signRequest(&$args, $secret){
  ksort($args);
  $sig = '';
  foreach($args as $k => $v){
    $sig .= $k . '=' . $v;
  }
  $sig .= $secret;
  $args['sig'] = md5($sig);
}

Seriously, that’s it.  Here’s the output I received from the command line.

jmathai@[~/Y/photos]: php fb.php
<?xml version="1.0" encoding="UTF-8"?>
<photos_upload_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd">
<pid>XXXXXXXXXXXXXXXXXX</pid>
<aid>XXXXXXXXXXXXXXXXXX</aid>
<owner>XXXXXXXXXXX</owner>
<src>http://photos-d.ak.fbcdn.net/photos-ak-sf2p/v645/2/72/500273081/s500273081_1648227_6794.jpg</src>
<src_big>http://photos-d.ak.fbcdn.net/photos-ak-sf2p/v645/2/72/500273081/n500273081_1648227_6794.jpg</src_big>
<src_small>http://photos-d.ak.fbcdn.net/photos-ak-sf2p/v645/2/72/500273081/t500273081_1648227_6794.jpg</src_small>
<link>http://www.facebook.com/photo.php?pid=1648227&amp;id=500273081</link>
<caption/>
<created>1227781696</created>
<story_fbid>0</story_fbid>
</photos_upload_response>

Additional reading
You’ll want to get more familiar with Facebook’s API and some of the nuances when posting photos. Here are some links to help get you on your way.

• http://wiki.developers.facebook.com/index.php/Photos.upload
• http://wiki.developers.facebook.com/index.php/How_Facebook_Authenticates_Your_Application
• http://wiki.developers.facebook.com/index.php/Extended_permission
• http://code.google.com/p/servicesfacebook/

If you don’t already have Quicksilver installed then go get to know it (here’s an indepth video tutorial).  Ok, now that you’re familiar with the basics of using Quicksilver let’s do the second most important thing you can for your computer: install the Delicious addon for Firefox.

Take Quicksilver on a test drive
Now that we’ve got everything we need let’s hook it all up.  First, open up Quicksilver and go to the preferences pane.  You can do this by pressing command + ,.  Once in the preferences pane, select plugins and make sure that Social Bookmarks is checked.  Then go to catalog and select custom from the left menu and add Social Bookmarks to the list if it’s not already there.

You can enter your Delicious username and password by clicking the i icon in the lower right of the preferences pane.  It’s as easy as that.

See it all in action
Now, open Quicksilver and start typing something in the title of one of the pages you’ve bookmarked.  You’ll wonder how you ever lived without Quicksilver, Firefox and Delicious.  Below is what I get when type ronpaul:

OSX + Quicksilver + Firefox + Delicious = Bookmark Heaven