This gives you something like the following:
curl -w "Connect time: %{time_connect} Time to first byte: %{time_starttransfer} Total time: %{time_total} \n" -o /dev/null www.google.com
Connect time: 0.402 Time to first byte: 0.453 Total time: 0.475

Hope this is useful to someone else.

function str_replace_last( $search, $replace, $subject ) {
    if ( !$search || !$replace || !$subject )
        return false;

    $index = strrpos( $subject, $search );
    if ( $index === false )
        return $subject;

    // Grab everything before occurence
    $pre = substr( $subject, 0, $index );

    // Grab everything after occurence
    $post = substr( $subject, $index );

    // Do the string replacement
    $post = str_replace( $search, $replace, $post );

    // Recombine and return result
    return $pre . $post;
}

Hope someone else finds this useful.

What I ended up doing is using the Yahoo! GeoPlanet API. This allowed me to do a query of my city or state name and get a place resource, then use that to find the continent that the place resource belongs to.

So first things first, you’re going to need an app id from Yahoo!, so if you don’t already have one you’ll need to get one. Then you just need to make a request like the following:
http://where.yahooapis.com/v1/places.q(CITY_OR_STATE)?appid=YOUR_APP_ID
Where CITY_OR_STATE is the query term you’re searching for and YOUR_APP_ID is the Yahoo! app id from above. Then you’ll get back something like the following:

<places xmlns="http://where.yahooapis.com/v1/schema.rng" xmlns:yahoo="http://www.yahooapis.com/v1/base.rng" yahoo:start="0" yahoo:count="1" yahoo:total="300">
<place yahoo:uri="http://where.yahooapis.com/v1/place/2488042" xml:lang="en-US">
<woeid>2488042</woeid>
<placeTypeName code="7">Town</placeTypeName>
<name>San Jose</name>
<country type="Country" code="US">United States</country>
<admin1 type="State" code="US-CA">California</admin1>
<admin2 type="County" code="">Santa Clara</admin2>
<admin3/>
<locality1 type="Town">San Jose</locality1>
<locality2/>
<postal/>
<centroid>
<latitude>37.338470</latitude>
<longitude>-121.885788</longitude>
</centroid>
<boundingBox>
<southWest>
<latitude>37.117840</latitude>
<longitude>-122.160027</longitude>
</southWest>
<northEast>
<latitude>37.555859</latitude>
<longitude>-121.535393</longitude>
</northEast>
</boundingBox>
<areaRank>6</areaRank>
<popRank>12</popRank>
</place>
</places>

You want to grab the woeid (in this case 2488042) for the next part. Next, we need to lookup the continent this place resource belongs to. To do this we make a request like so:
http://where.yahooapis.com/v1/place/THE_WOEID/belongtos.type(29)?appid=YOUR_APP_ID
Where THE_WOEID is the woeid we found in the last step (2488042 in this example) and YOUR_APP_ID is your app id again. This should return something like the following:

<places xmlns="http://where.yahooapis.com/v1/schema.rng" xmlns:yahoo="http://www.yahooapis.com/v1/base.rng" yahoo:start="0" yahoo:count="1" yahoo:total="1">
<place yahoo:uri="http://where.yahooapis.com/v1/place/24865672" xml:lang="en-US">
<woeid>24865672</woeid>
<placeTypeName code="29">Continent</placeTypeName>
<name>North America</name>
</place>
</places>

Where North America is clearly what we want to pull out of it.

I was doing this in PHP, so here’s a quick and dirty PHP example:

function continent_lookup( $search ) {
    if ( strlen( $search ) == 0 )
        return false;

    $search = urlencode( $search );

    $app_id = 'YOUR_APP_ID';

    $res = file_get_contents( "http://where.yahooapis.com/v1/places.q($search)?appid=$app_id" );
    preg_match( "/<woeid>([0-9]+?)<\/woeid>/", $res, $match );

    if ( !$match )
        return false;

    $woeid = $match[1];

    $res = file_get_contents( "http://where.yahooapis.com/v1/place/$woeid/belongtos.type(29)?appid=$app_id" );
    preg_match( "/<name>(.+?)<\/name>/", $res, $match );

    return $match[1];
}

Hope this helps someone else out there. Let me know if you have any feedback.

function png_has_transparency( $filename ) {
    if ( strlen( $filename ) == 0 || !file_exists( $filename ) )
        return false;

    if ( ord ( file_get_contents( $filename, false, null, 25, 1 ) ) & 4 )
        return true;

    $contents = file_get_contents( $filename );
    if ( stripos( $contents, 'PLTE' ) !== false && stripos( $contents, 'tRNS' ) !== false )
        return true;

    return false;
}

The first file check:
ord ( file_get_contents( $filename, false, null, 25, 1 ) ) & 4
will check for transparency in a 32-bit PNG. The second check
stripos( $contents, 'PLTE' ) !== false && stripos( $contents, 'tRNS' ) !== false
works to detect transparency in 8-bit PNG’s. Big thanks to this article which expains how these parts work in a bit more detail.

Depending on how likely you are to have transparency (or 32-bit png’s) you might want to modify this function to only do one file access, but the advantage here is that if it is a 32-bit png with transparency we only need to read in part of the file. This was faster in my early testing of a sample of our images, but your results may vary.

Hope this helps someone else out there.

The interesting part of it, though, is that the emails all dump to a PHP script.  This script looks at the email address it was sent to, and checks a database to see if that email address has been seen before or not.  If it hasn’t, it will forward that email to my “real” email address.  If it has, it will ignore it.

This has been super helpful when making test accounts on services too as it’s easy to get another email address, but I don’t have to worry about checking a weird email account or getting a bunch of spam afterwards.  Just thought I’d mention it in case anyone else out there does a lot of this stuff.

I recently had a chance to go back through the script though and update it. It now uses jQuery, works with the current Gmail structure, and loads Gravatars for all open messages (the last one didn’t). It’s not perfect though. It will not yet load Gravatars if you click to open a collapsed message in a conversation (only the expanded messages upon first opening will have the Gravatar images loaded). It works pretty well otherwise, though, and it’s nice to see faces with my emails again.

I’ve got a screen shot below if you want to see what it looks like. If you’d like to get the script for yourself, I’ve posted it here. Just install Greasemonkey, click the link, and choose “install” when the popup comes up. Enjoy.

1. First, download the extension.
2. Next, find your Firefox profile folder.
3. In your profile folder, find and open the “extensions/ShortenURL@loucypher/defaults/preferences” folder.
4. You should then find a file named shortenURL_prefs.js – open it in any text editor.
5. You should see two large blocks of similar lines repeating – find the last one in the first block (as of writing this it is pref("extensions.shortenURL.name.145", "w3t.org"); and add a new line below it (incrementing the number) and swap out the name w/ whatever you want to reference your url shortener as. (in my case pref("extensions.shortenURL.name.146", "jfox.in");
6. Continue to the end of the file and you should find a matching url line pref("extensions.shortenURL.145", "http://w3t.org/?module=ShortURL&file=Add&mode=API&url=");. Add a new line below this one incrementing the number again (to match the one in the last step) and adding the url of the page to submit a url to shorten (the url will be appended to the end). For example: pref("extensions.shortenURL.146", "http://jfox.in/make-tiny.php?url="); (note the example here won’t actually work because my shortener is private).
7. Save the file and restart Firefox. Now go to Tools->Add-ons, find ShortenURL in the list and select “preferences”. You should now be able to find your custom shortener in the list using the name you provided above (in my case jfox.in). Select your preference and enjoy!

A quick trailing note: This all assumes that your shortener has an interface that allows a url to be passed as a GET parameter and returns the shortened url in plain text as a result of that request. This is straight forward to implement, but worth mentioning. You should now be able to shorten simply by right-clicking and selecting the “Shorten this page URL” option (which will also copy the short url to your clipboard and put it in the location bar). Enjoy!

• Full control of the data – I can get at it wherever, however, and whenever I want to. I can also move it into different formats and systems at will.
• Full control over the service – I can add whatever features I want in whatever interface I want and not have to worry about the 15 other features I’ll never use that clutter up my UI.
• Full control over the URLs themselves – I don’t have to worry about the domain shutting down, remapping my short URLs some time in the future, or what type of header redirect they’re using to make sure I get my Google juice.
• It was fun – Perhaps the biggest reason I wanted to do this was because it’s such a simple project and it was kind of a fun exercise for me.

Anyone that is code savvy and is considering doing this – whatever your reasons – I definitely recommend doing it. It was simple and something I enjoyed, and it gives me the control I want in such a simple application. Not every problem makes sense to roll your own solution for, but this is one that does in my mind since it’s so simple.

I honestly wouldn’t be surprised if we see more web services offering their own custom URLs. It allows a bit more brand recognition and all the control issues I mention above. It also seems that short URL services aren’t going away anytime soon.

Do you have any thoughts on the merits of short URL services? Have you written your own or considered doing so?

So, how does one get around this unfortunate problem?  Well, the best method I’ve found is to set the innerHTML property when the element is not yet attached to the DOM or is attached in a “safe” place (usually at the BODY tag).  To make this process simpler, I generalized this into a function that creates a new DOM node of the same type, preserves any attributes I care about, sets the innerHTML property, and replaces the original node in the DOM with this new node having the desired innerHTML.  Here’s the function for reference:

function replace_html(el, html) {
	if( el ) {
                var oldEl = (typeof el === "string" ? document.getElementById(el) : el);
                var newEl = document.createElement(oldEl.nodeName);

                // Preserve any properties we care about (id and class in this example)
                newEl.id = oldEl.id;
                newEl.className = oldEl.className;

                //set the new HTML and insert back into the DOM
                newEl.innerHTML = html;
                if(oldEl.parentNode)
        	        oldEl.parentNode.replaceChild(newEl, oldEl);
                else
		        oldEl.innerHTML = html;

                //return a reference to the new element in case we need it
                return newEl;
	}
};

Hopefully this function will help someone out there work around this problem a little faster than I originally did.