“The (most) obvious question: Why would I install this plug-in rather than switch browsers to Chrome? The folks at Google point to IT lockdown that won’t allow users to install a new browser; Ars wonders whether such restrictive IT departments would be any more likely to approve this plug-in. If nothing else, it’s a pretty bold move on the part of Google.”

If you’re interested, Jim Ray dug into the details of how it works. Personally, I don’t think this will solve anyone’s IE6 problems, but it’s a fascinating development, and worth keeping an eye on.

“The irony here, as I see it, is that an old, insecure feature Microsoft built to try to beat Netscape is now being used by Microsoft’s biggest current rival to patch IE.”

On the IE Blog, Tony Ross published a list of mostly technical differences between the two. Perhaps more useful for web developers is this article by Estelle Weyl outlining some of the presentation differences between the two, such as border handling and box model differences.

Why does this matter? Because I’ve heard some otherwise intelligent web developers (including Microsoft’s Expression Web team, which uses IE8’s Compatibility Mode for IE7 testing) claim that testing will be much easier now, since you can test everything in one place.

To be sure, tools like Expression Web or the old Stand-Alone IE installers are helpful, but don’t fool yourself into thinking that they are an accurate representation of a “clean” IE6 or IE7 installation. To test against those, you’ll still need to resort to more thorough measures like keeping separate machines around, or using the free Virtual PC images for IE6, IE7, and IE8.

In the first paragraph, you can see the layout gap problem, and in the second paragraph, you can see the paragraph as it should be displayed, by using the following CSS rules.

sup {
	vertical-align: baseline;
	position: relative;
	bottom: .33em;
}
sub {
	vertical-align: baseline;
	position: relative;
	bottom: -.33em;
}

The browser shifts the super and subscript text by using the vertical-align CSS property, which leaves gaps in the paragraph. By resetting this property to the defaul value of baseline, we get rid of the gaps. Then we restore the appearance of the text by using position: relative; and shifting the bottom up or down by .33em. Since this uses ems, you can use these lines in your reset stylesheet, no matter what font treatment you use on your site. Now go forth, and may paragraph gaps never plague you again!

Well-written software can have intelligent defaults, too, and you can give your users that same feeling of anticipating their needs. Here are a few examples of programs that found a clever way to save their users’ time with common, repetitive tasks.

Leopard’s Smart File Rename Feature

Traditionally, to rename a file, you click once, and then again in the filename, and then the entire thing is highlighted, including the extension. If you then start typing, the extension is lost, so every time you have to re-highlight just the name portion.

But in Leopard, Apple changed the function to automatically highlight everything but the extension. They recognized that most of the time, you’re only changing the filename and not the extension. This is a tiny, tiny change, but it saves you a highlight action every time you rename a file.

TortoiseSVN’s Auto-Expanding Collapsed Directories

TortoiseSVN includes a browser to navigate the SVN tree to find the directory you want to check out. Since loading all the directories takes time, when you first open the browser, it just shows you the part of the filetree that you’re in. To access the full tree, you just collapse the top directory, and then expand it again, at which point the program loads everything else.

A recent version of the program changed the behavior so that when you collapse the top-level directory, they automatically open it right away, and load the full tree. Saving a single click isn’t a big deal, but it makes you feel like the program is anticipating your needs.

Xbox 360’s Annoying Device Selection Prompt

Okay, now for an example of where an intelligent default is desperately needed. The Xbox 360 has an optional hard drive to save your games to. You can also use a memory unit. As a result, games need to include a prompt asking you whether to save the game to your hard drive or the memory unit. The problem arises when you have only one storage device connected.

If you only have a hard drive, then you only have one option when they ask you where to save your game, but they ask anyways. Here’s a suggestion for the UI guys developing all those games: If there’s only one possible answer to a question, don’t bother asking!

I’ve attended An Event Apart four years running now. It is, hands-down, the finest web conference around, and if you work on the web at all, whether you’re a designer, developer, copywriter, or client-services, I cannot recommend it highly enough.

Reviewing my notes from previous conferences, I noticed that there were some running themes. Each year, I’ve come to expect that Jeffrey Zeldman will discuss how to manage relationships with clients who sometimes have little or no respect for what we do. Eric Meyer will talk about a currently hot topic in the CSS arena (usually one he is at the forefront of), and a bevvy of talented designers, copywriters, usability experts and other roles will share their insights.

So, here is my take on the running themes of the conference, as well as my individual key takeaways from each year. Naturally, these reflect my interest in front-end code, so you might have gotten more from different speakers than I did, but I think it will still help give you an idea of what you can expect from An Event Apart.

Running Themes:

Sell ideas, not pixels: Every year, this message comes up in one form or another. Simply put, if you just show your clients comps, without explaining the reason behind them, they’ll get hung on little details like “I don’t like orange,” or “that font is ugly.” Instead, be clear about the theme behind your comps, and then they will discuss the ideas, like “The corporate one is too impersonal, but we really liked the human one with all the photos.”

Avoid bad clients: After sharing horror stories of clients who were a bad fit for him (or vice-versa), Zeldman always hammers this point — working with problem clients is rarely worth the effort it takes. Cut them loose and focus on the ones that mesh well with your organization.

Start with the user: Always strong advocates of user-centered design, this point has come up again and again. At the end of the day, it doesn’t really matter if the designer and client are happy — it matters whether the users are happy. If your site doesn’t start by asking what the user needs, you’ll have troubles.

Start with the content: I include this because Zeldman changed his slides around this year, and now says to start with the content and end with the user, but I think the point is ultimately the same. Design should be driven by the content, which should be driven by the user’s needs.

Seattle 2009

• Jeffrey Zeldman says “Research produces achievable goals and makes you a credible partner.”
• Eric Meyer says “HTML 5 allows interesting new patterns, but there are still limitations.”
• Tara Hunt says “Use your competitor’s tools until you love them.”
• Kristina Halvorson says “Repeat after me: I will never again say Launch. Instead, I will say Life Cycle.”
• Dan Cederholm asks if IE6 is the new Netscape 4 (to wild applause). Concludes with a quote from Eric Meyer saying that you can stop supporting IE6 only when your site’s stats say you can. Stats from other sites are “worse than useless.”

San Francisco 2008

• Zeldman says good web design starts with the user — focus on their needs, not the client’s.
• Eric Meyer discussed CSS Frameworks, and how they grew out of reset stylesheets. He recommends avoiding other people’s frameworks except as a jumping-off point. Ideally, you should be creating your own.
• Dan Cederholm says “Progressive Enhancement means really cool stuff that doesn’t work in IE.”
• Tantek Çelik discussed microformats.
• Eric Meyer talked about reset and debug stylesheets.

Seattle 2007

• Eric Meyer illustrated that the default behavior of all HTML elements is defined by the browser, and each browser defines things slightly differently – especially font handling – which is why he advocates the use of a reset stylesheet.
• Zeldman says that content drives traffic, freshness counts, and language is the main interface on most sites, which is why all sites have large writing and editorial budgets. When everyone laughed, he asked for raised hands if you have a writing budget or a copy czar. When only a few people raised their hands, he said “In conclusion, get a writing budget and hire a copy czar.”
• Khoi Vinh discussed grid-based layouts.
• Shaun Inman discussed progressive disclosure of information in Mint.
• Eric Meyer recommended Dean Edwards’ IE7 scripts to make IE6 behave.

Seattle 2006

• Eric Meyer discussed CSS bar graphs and child selectors.
• Jeffrey Zeldman says “The client is not an idiot. This is very important, and I want you all to write this down. To put it another way, Don’t choose clients who are idiots. To put a marketing spin on it, Choose good clients.”
• Jeffrey Zeldman says “Copy is a precious opportunity to define your brand. It’s also the cheapest and easiest thing on your site to fix, generally.”
• Eric Meyer discussed the One True Layout, saying “Alex published this technique last year in October 2005, nine years after the CSS1 rules were published. As far as I can tell, no one else thought of this before him, including me, which is why I hate him.”
• Kello Goto recommended user testing.

“This isn’t a super-fun conference where you come here to be entertained and then forget everything and get drunk.”
– Jeffrey Zeldman, An Event Apart: Seattle ‘09

How We Got Into This Mess

When I was hired at Pop Art in early 2006, there was no official Pop Art blog. The design team had their own site, which was sporadically updated and not branded as a Pop Art site. Several members of the dev team also had work blogs, but again, they were not branded. As somewhat of a blogging zealot, I pushed hard to standardize these onto one site, and in August, I got the go-ahead to set something up.

When I started looking into solutions, I was working with a few assumptions. First, that the existing blogs would stay up, and the central blog would syndicate their posts by pulling in their RSS feeds. Secondly, despite my strong preference for Wordpress, that it was not a viable option for us. That’s because we’re a Microsoft shop, so we don’t have a lot of PHP experience in-house, and we don’t have any Apache boxes to host the site on. Also, since I was assuming we wanted multiple blogs syndicated at one domain (rather than a single blog with multiple authors), there wasn’t a good way to do that with Wordpress at the time (Wordpress MU hadn’t really taken off at the time).

Given those assumptions, we ended up installing Community Server. I felt good about this because it was the product used to host all the blogs at Microsoft, and appeared to be well-supported and active.

Increasing Difficulties with Community Server

However, installation and customization were a nightmare. After a lengthy struggle to get everything set up correctly, it became increasingly clear that some of our assumptions were inaccurate.

Although we started with independent blogs being syndicated, our CEO eventually wrote a company blogging policy disallowing this, so we ended up with a Community Server site that had 20+ single-author blogs being aggregated onto a single homepage to give the appearance of a standard multiple-author blog. We weren’t taking advantage of anything the multiple-blog scenario was originally set up to do.

Over time, we found out that Community Server was not only difficult to customize, it was also poorly supported. After we purchased and installed CS2007, they released two further versions, and stopped supporting ours. (When we contacted them about purchasing an updated for our license to add more blogs, we were told our version was no longer supported, and they offered to let us upgrade at a discounted price of $900. We didn’t purchase that upgrade, and three months later, they announced that they were changing their license structure again, and we would now have to pay full price for a brand new license if we wanted to upgrade.) I know that companies make money by releasing new versions, but it seems crazy that less than two years after we bought their product, they wouldn’t support us at all without a full upgrade.

To cut a long story short, the straw that finally broke the camel’s back was when we decided to integrate Twitter into our blogs. We were able to add the javascript twitter script to the sidebar to display the Pop Art feed easily, but in order to add individual twitter feeds to the profile page, we were going to need to bring in the .NET programmers, who are always really busy — and I realized that if we were using Wordpress, I could do everything myself.

There were other factors, including our frustration with the licensing situation, and the fact that we didn’t need the overly complicated multiple blog situation anymore, but the customization difficulties were the kicker. Once I was able to assure our CEO that switching to Wordpress wouldn’t lead to a repeat of this situation in a few years, we had the green light to make the switch.

Exporting Posts from Community Server

Getting our posts from Community Server to Wordpress was our first hurdle. Out of the box, there’s no way to make it work, other than having Wordpress scrape the RSS feed — and that would lose all the comments. Thankfully, other people had already done the legwork for me. Bear with me here.

Aaron Lerch wrote a great post in August 2007 about switching from Blogger to Wordpress using BlogML. I already knew from when we originally set it up that Community Server supports BlogML, and Aaron wrote a module for Wordpress to import from BlogML format.

Then, in October 2007, Rob Walling wrote a post about switching from Community Server 2007 to Wordpress. He updated Aaron’s Wordpress importer because Wordpress 2.3 switched from categories to tags.

Finally, in October 2008, Kavinda Munasinghe wrote a post about switching from DasBlog to Wordpress, and once again, updated Aaron’s Wordpress importer.

So, I grabbed the BlogML Export module for Community Server 2007, and Kavinda’s updated BlogML Importer for Wordpress, and set about my business.

Importing Posts to Wordpress

The first problem I ran into is that I couldn’t get one big export file of every blog in our Community Server installation, I had to create an export file for each one.

The second problem I ran into is that my exports didn’t import correctly. Now, I have no idea if the problem was from one of the versions of the importer, or if the exporter wasn’t working correctly, or even if the latest version of Wordpress just has a slightly different database. What it boiled down to is that I had to manually reformat each of my 32 export files.

The biggest issue was with categories/tags. First of all, all my tags were being imported as categories. I was willing to ignore this, since Wordpress has a “convert categories to tags” feature, but it was still annoying. In addition to that, however, all the categories were importing as numbers. Turns out that Wordpress was grabbing the category ID instead of the category name.

I looked at both the importer and the exporter, but I didn’t have the programming know-how to fix it, so ultimately, I just wrote a simple regular expression to reformat all the categories so that their names were in the ID attribute so they would import correctly.

In addition to that, author names weren’t importing correctly, draft status posts were being published, and a couple of older blogs where the authors had copy-and-pasted from Word were bringing in a bunch of crazy custom microsoft markup. All in all, I probably spent about 3-4 hours manually cleaning up all my export files. This all sounds like a huge pain (and it was!), but I’m happy to say that once I was done, everything imported perfectly.

Redirecting Old Posts

The final thing I needed to do was set up a 301 redirect for all the old posts. Aaron’s importer script gives you a file that you can use to build a list of redirects in your .htaccess file, but I was sure there was a better way. After a bit of digging, I found a forum post about using mod_rewrite to change dynamic to static URLs that helped me write the following regular expression to redirect from our old permalinks to our new ones.

RewriteRule
     ^([^/]+)/archive/([^/]+)/([^/]+)/([^/]+)/([^/]+).aspx$
     http://blogs.popart.com/$2/$3/$5 [R=301,L]

Note that normally, that would all appear on one line. I’ve broken it up for readability. That looks for urls like /scott-vandehey/archive/2006/11/09/post-title.aspx and redirects them to /2006/11/post-title/. With that one rule in our .htaccess file, all our old blogs posts would automatically get a 301 redirect to the new URLs.

Now that we’ve made the switch, I’m really happy we spent the time on it. We took the opportunity to redo the design to better match our main site, and the template engine in Wordpress is a real joy to work with — and well-documented, more importantly! I’m confident that we’ll be able to handle the evolving needs of our company in the future, and informally, I can say that everyone seems happier using the new system. The transition was a pain, but the results were worth it.

Use RSS Excerpts to Strip All HTML

/*
	just like the_excerpt, but really strips all the HTML, including BR tags
*/
<p><?php the_excerpt_rss(); ?></p>

We wanted to display a post excerpt on most pages. Normally, I would just use wordpress’ the_excerpt function. It automatically displays the post excerpt if it exists, and if not, then it grabs the first 50 words of the post, and even strips the HTML! Sounds great, right? Except for one thing — it doesn’t strip line breaks, so instead of a page full of single-paragraph excerpts, I had several posts with two small paragraphs displaying. Not a big deal, but it was messing up our design.

After doing a little digging in the wordpress documentation, I found that the_excerpt_rss does exactly what I was looking for. It’s intended to be used in RSS templates, but you can use it in your regular pages and it works just as well. The only hiccup is that you’ll need to wrap it in a <p> yourself.

Use the Nickname Field for Job Titles

<?php the_author_meta('nickname'); ?>

Our design shows the job title under everyone’s name. There’s no “job title” field in the user accounts, but I was able to repurpose the nickname field. To display it in the site, just use the code shown above in your post templates. Remember, the people looking at your site won’t know that you’re using the “wrong” database field! (You know, unless you tell them, like I’m doing.)

Bit.ly Shortener for Twitter Links

/*
	Bit.ly URL Shortener
	Automatically shorten a URL using the Bit.ly API
	based on code from http://davidwalsh.name/bitly-php
*/
function make_bitly_url($url) {
	$login = 'YOUR BIT.LY LOGIN';
	$appkey = 'YOUR BIT.LY API KEY';
	$format = 'xml';
	$version = '2.0.1';
	$bitly = 'http://api.bit.ly/shorten?version='.$version.'&longUrl='.urlencode($url).'&login='.$login.'&apiKey='.$appkey.'&format='.$format;
	$response = file_get_contents($bitly);
	//parse depending on desired format
	if(strtolower($format) == 'json') {
		$json = @json_decode($response,true);
		return $json['results'][$url]['shortUrl'];
	} else { //xml
		$xml = simplexml_load_string($response);
		return 'http://bit.ly/'.$xml->results->nodeKeyVal->hash;
	}
}

Adding a “retweet this” link at the bottom of every post is pretty easy. You just link to twitter.com and pass a “status” query string in the URL with whatever you want their tweet to include — namely, the URL to the post they’re retweeting. But our URLs can get pretty lengthy, since they include the post title. Obviously, with Twitter’s 140-character limit, every character counts. To get around this, I found some code by David Walsh to make a bit.ly short URL. It works great, but you’ll need to register for an API key on their site to use it. This code goes in your functions.php file, and then you can call it from any post loop like this:

<?php echo make_bitly_url(get_permalink()); ?>

Use a Custom Default Gravatar

/*
	Add new default avatars
	based on code from http://wpengineer.com/add-avatar-to-wordpress-default/
*/
if ( !function_exists('fb_addgravatar') ) {
	function fb_addgravatar( $avatar_defaults ) {
		$stormtrooper = get_bloginfo('template_directory').'/images/avatar.png';
		$avatar_defaults[$stormtrooper] = 'Storm Trooper';
		return $avatar_defaults;
	}
	add_filter( 'avatar_defaults', 'fb_addgravatar' );
}

Wordpress’ built-in support for gravatars in comments is fantastic, but if your commenters don’t have a gravatar account, the default avatar will be displayed. Wordpress lets you choose between a simple gray silhouette or several dynamically generated icons, none of which really fit our design. Luckily, I found this code that lets you add your own default avatar to the list — in our case, a lovely photo of a storm trooper. This code goes in your functions.php file, and it adds a new option to the default gravatar list in your admin area.

Use HTML in User Profiles

/*
	Turn off HTML filter for user profiles
*/
remove_filter('pre_user_description', 'wp_filter_kses');

Our fancy profile pages use the “Biographical Info” field in the user profiles. The only problem is that by default, wordpress strips any HTML from it. You can disable that feature by adding this bit of code to your functions.php file.

Add More RSS Feeds

<link rel="alternate" type="application/atom+xml" title="<?php bloginfo('name'); ?> Full Posts" href="<?php bloginfo('atom_url'); ?>" />
<?php
	// add comments feed on single-post pages
	if (is_single()) {
		while (have_posts()) : the_post();
			if ('open' == $post->comment_status) : /* If comments are open */
?>
<link rel="alternate" type="application/atom+xml" title="Comments on <?php the_title(); ?>" href="<?php bloginfo('url'); ?>/index.php?feed=atom&amp;p=<?php the_ID(); ?>" />
<?php
			endif;
		endwhile;
		rewind_posts();
	// add category feed on category archives
	} else if (is_category()) {
		$category = get_the_category();
?>
<link rel="alternate" type="application/atom+xml" title="Posts in the <?php echo $category[0]->cat_name; ?> category" href="<?php echo get_category_feed_link( $category[0]->cat_ID, 'atom' ); ?>" />
<?php
	// add tag feed on tag archives
	} else if (is_tag()) {
?>
<link rel="alternate" type="application/atom+xml" title="Posts tagged with <?php single_tag_title(); ?>" href="<?php echo get_tag_feed_link( get_query_var('tag_id'), 'atom' ); ?>" />
<?php
	// add author feed on author pages
	} else if (is_author()) {
		if(isset($_GET['author_name'])) :
		$curauth = get_userdatabylogin($author_name);
		else :
		$curauth = get_userdata(intval($author));
		endif;
		$authorfeedlink = get_author_feed_link( $curauth->ID, 'atom' );
	?>
<link rel="alternate" type="application/atom+xml" title="Posts by <?php echo $curauth->display_name; ?>" href="<?php echo $authorfeedlink; ?>" />
<?php
	}
?>

Finally, one of the best (and relatively unknown) features of wordpress is that you can get an RSS feed for just about every page on the site, just by adding /feed/ to the end of the URL. I wanted to take advantage of this feature to add link elements for those special feeds on different pages — for example, a feed for an author’s posts on their profile page, or for comments on a post on that post’s page. The above code is a little convoluted, but it includes all the logic to add the following feeds on the appropriate pages:

• Complete blog feed on every page
• Comments feed on individual post pages
• Category feeds on category pages
• Tag feeds on tag pages
• Author feeds on author profile pages

Note that I’ve set this up to provide Atom feeds, but you can change it by replacing every instance of atom with rss2. This code goes in your header.php file, near the rest of your meta and link elements.

This makes sense in that HTML 5 is already gaining traction, and we’ve seen lots of talk in the web community about switching back to HTML, but I never expected to see development halted like this.

“W3C hopes to accelerate the progress of HTML 5 and clarify W3C’s position regarding the future of HTML.”

Nice to know that the W3C is clearly picking a side and throwing their support behind one product, though.

Since we were switching to Wordpress, I checked out a bunch of Twitter plugins, but ultimately found them all to be unreliable or just missing features. In the end, I hacked together one of my own, based heavily on code by Ryan Barr. His PHP script was very nearly perfect, but I ran into three problems.

First, his script echoed out the exact date and time of the tweet, but I wanted the fancy “2 hours ago” style dates. To do that, I used a chunk of code from Stack Overflow. Now, I’m far from an advanced PHP programmer, so I’m sure that this code could be cleaned up and condensed down to something like 12 characters, but I like this because it works, and it’s very easy for a mid-level programmer like myself to understand.

<?php
/*
	Relative Time Function
	based on code from http://stackoverflow.com/questions/11/how-do-i-calculate-relative-time/501415#501415
	For use in the "Parse Twitter Feeds" code below
*/
define("SECOND", 1);
define("MINUTE", 60 * SECOND);
define("HOUR", 60 * MINUTE);
define("DAY", 24 * HOUR);
define("MONTH", 30 * DAY);
function relativeTime($time)
{
	$delta = strtotime('+2 hours') - $time;
	if ($delta < 2 * MINUTE) {
		return "1 min ago";
	}
	if ($delta < 45 * MINUTE) {
		return floor($delta / MINUTE) . " min ago";
	}
	if ($delta < 90 * MINUTE) {
		return "1 hour ago";
	}
	if ($delta < 24 * HOUR) {
		return floor($delta / HOUR) . " hours ago";
	}
	if ($delta < 48 * HOUR) {
		return "yesterday";
	}
	if ($delta < 30 * DAY) {
		return floor($delta / DAY) . " days ago";
	}
	if ($delta < 12 * MONTH) {
		$months = floor($delta / DAY / 30);
		return $months <= 1 ? "1 month ago" : $months . " months ago";
	} else {
		$years = floor($delta / DAY / 365);
		return $years <= 1 ? "1 year ago" : $years . " years ago";
	}
}
?>

Secondly, and most important, Ryan’s code didn’t cache the results. That’s obviously bad form, but I didn’t really think about trying to fix it until Apple’s WWDC traffic drove Twitter to a standstill while I was testing our new site. Realizing that our Twitter feeds would die anytime anything big happened on the internet motivated me, and I was able to integrate some caching code from Kien Tran and Snipplr that meshed well with Ryan’s existing code.

When I was done, I had a fully functional script that created a cache file for each twitter feed, and only tried to update it every ten minutes. I was especially pleased to discover that it worked when Twitter again ground to a halt due to the Iran elections and Michael Jackson’s death in the last few weeks.

So here’s the final code that we’re using on the Pop Art blog. It looks pretty overwhelming, but it’s basically broken down into three sections. First, it checks to see if the cache file exists, and whether it needs to be updated. Second, it parses the XML from the cache file to create a series of variables. Finally, it echos out a chunk of HTML for each tweet, or an error message if there aren’t any.

<?php
/*
	Parse Twitter Feeds
	based on code from http://spookyismy.name/old-entries/2009/1/25/latest-twitter-update-with-phprss-part-three.html
	and cache code from http://snipplr.com/view/8156/twitter-cache/
	and other cache code from http://wiki.kientran.com/doku.php?id=projects:twitterbadge
*/
function parse_cache_feed($usernames, $limit) {
	$username_for_feed = str_replace(" ", "+OR+from%3A", $usernames);
	$feed = "http://search.twitter.com/search.atom?q=from%3A" . $username_for_feed . "&rpp=" . $limit;
	$usernames_for_file = str_replace(" ", "-", $usernames);
	$cache_file = dirname(__FILE__).'/cache/' . $usernames_for_file . '-twitter-cache';
	$last = filemtime($cache_file);
	$now = time();
	$interval = 600; // ten minutes
	// check the cache file
	if ( !$last || (( $now - $last ) > $interval) ) {
		// cache file doesn't exist, or is old, so refresh it
		$cache_rss = file_get_contents($feed);
		if (!$cache_rss) {
			// we didn't get anything back from twitter
			echo "<!-- ERROR: Twitter feed was blank! Using cache file. -->";
		} else {
			// we got good results from twitter
			echo "<!-- SUCCESS: Twitter feed used to update cache file -->";
			$cache_static = fopen($cache_file, 'wb');
			fwrite($cache_static, serialize($cache_rss));
			fclose($cache_static);
		}
		// read from the cache file
		$rss = @unserialize(file_get_contents($cache_file));
	}
	else {
		// cache file is fresh enough, so read from it
		echo "<!-- SUCCESS: Cache file was recent enough to read from -->";
		$rss = @unserialize(file_get_contents($cache_file));
	}
	// clean up and output the twitter feed
	$feed = str_replace("&amp;", "&", $rss);
	$feed = str_replace("&lt;", "< ", $feed);
	$feed = str_replace("&gt;", ">", $feed);
	$clean = explode("<entry>", $feed);
	$amount = count($clean) - 1;
	if ($amount) { // are there any tweets?
		for ($i = 1; $i < = $amount; $i++) {
			$entry_close = explode("</entry>", $clean[$i]);
			$clean_content_1 = explode("<content type=\"html\">", $entry_close[0]);
			$clean_content = explode("</content>", $clean_content_1[1]);
			$clean_name_2 = explode("<name>", $entry_close[0]);
			$clean_name_1 = explode("(", $clean_name_2[1]);
			$clean_name = explode(")</name>", $clean_name_1[1]);
			$clean_user = explode(" (", $clean_name_2[1]);
			$clean_lower_user = strtolower($clean_user[0]);
			$clean_uri_1 = explode("<uri>", $entry_close[0]);
			$clean_uri = explode("</uri>", $clean_uri_1[1]);
			$clean_time_1 = explode("<published>", $entry_close[0]);
			$clean_time = explode("</published>", $clean_time_1[1]);
			$unix_time = strtotime($clean_time[0]);
			$pretty_time = relativeTime($unix_time);
			?>
				<li>
					<p class="tweet">
						< ?php echo $clean_content[0]; ?>
						<small>< ?php echo $pretty_time; ?></small>
					</p>
				</li>
			<?php
		}
	} else { // if there aren't any tweets
		?>
			<li>
				<p class="tweet">
					I have been terribly busy recently shoveling pixels and
					clearing out the tubes that make up the Internet, so I
					haven't had a chance to tweet recently. I am truly very
					sorry about this, so with just a bit more prodding I'll
					update as soon as possible.
				</p>
			</li>
		<?php
	}
}
?>

You’ll notice that I’m creating more variables than I actually need, noticeably the ones for the user names. On the Pop Art blog, we’re always showing just one person’s tweets at a time, but the code is built to allow you to pass a list of twitter accounts, and it’ll pull them all in. We used that code on another website, and I just left it in place here in case I wanted to use it at some point in the future. Since the variables already exist, I would just need to add them to the output HTML and they would show up.

Which brings me to the final problem I ran into. Ryan’s script uses the Twitter search API, which is great because it gives you the option of pulling in multiple twitter accounts. The downside of the search API is that it will only return recent tweets (the documentation says 7 days, but it looks like it actually returns two weeks).

I did some digging into the API documentation, and there’s no way around this. Twitter has two APIs, the search API and the REST API. The search API is more full-featured, including search operators and automatic link highlighting, with the downside that it only searches recent tweets. The REST API will return all tweets for a user, but it won’t highlight links, merge multiple twitter feeds, and worst of all, it requires a login.

Given those restrictions, I left the code using the search API, despite the restriction. To make the best of the situation, we wrote a funny error message for users with no tweets, and asked everyone linking their Twitter account to post at least once a week.

If you’re reading this in your feed reader, then our RSS feed has automatically redirected, and you shouldn’t have any problems. But in case you’re a stickler for official URLs, or you haven’t subscribed, our new feed can be found at blogs.popart.com/feed/atom/.

In the next few days, there are some more posts coming, including one from Mark about the new design, one about how we integrated Twitter, one about some nifty Wordpress tricks we learned, and a long one about our experience converting from Community Server 2007 to Wordpress (long story short: it makes scaling Everest look like walking up the stairs).

So please: snoop, dig, stop and smell the roses. And welcome to the redesigned and improved Pop Art Blog, it’s where the magic happens (or something like that).