I tweeted the link to @ricardovice who was nice enough to add my page to his canonical list of wasted domains. There wasn’t really a point to the page but I was kind of interested to see how much traffic I could get from riding the coat tails of funnier people than myself. The traffic I did receive wasn’t extraordinary but in twelve hours I got 3,800 hits. 95% of that was purely from Ricardo’s list. The remaining was from Hacker News (I shared the link in a comment thread) and my meager 100 Twitter followers. Only 24 people followed the link through to my website.

I’m not going to pretend that there are any great lessons to be learned from this. It was fun to be able to launch a concept including purchasing the domain and some dodgy Photoshop hackery in twenty minutes. Getting traffic is always nice too. As a side note I actually own a Windows Phone 7 device and think the Nokia chose was a decent one, especially considering how much Microsoft is throwing money at them.

var Car = new Class({
	Extends: Vehicle,
	Implements: [Options],
 
	options: {
		wheels: 2,
	},
 
	setOptions: function(options) {
		if (options.wheels < 3) {
			throw new Error("That's not a car.");
		} else {
			this.parent(options);
		}
	}
});

Apparently mixin methods like setOptions don’t act like inherited functions in Mootools’ class implementation. The obvious fix is to make the class inherit from the mixin directly.

var Car = new Class({
	Extends: Options,
 
	// Code omitted
}

This works, but we’ve lost the ability to create a sane object hierarchy. Thankfully the Options variable I added to the Implements array is just a reference to the class used to implement the mixin. So it is possible to call the parent method manually, just like I would without Mootool’s magic this.parent method.

var Car = new Class({
 
	// Code omitted
 
	setOptions: function(options) {
		if (options.wheels == 2) {
			throw new Error("That's not a car.");
		} else {
			Options.prototype.setOptions.call(this, options);
		}
	}
}

This works exactly like I hoped. The same approach would obviously work for other mixins like Events and Chain.

As a side note, it’s worth mentioning that Options.prototype.setOptions is actually pointing to a wrapper method which does a bit of Mootools-specific magic and validation; like ensuring the function is not protected. Fortunately the wrapper is written in a sane enough way that calling it from another object like this works OK.

The web ceased long ago of being a mere tool for sharing text documents. Images, sound and interactivity via JavaScript have all shifted the web towards the multimedia future we have long been promised. At the same time the iPhone and its App Store have raised consumers expectations of what their web enabled devices are capable of. Web developers are striving to meet these new expectations and are taking their lead from the desktop to create more interactive web applications.

Read the article on Brightlabs.

A peek at my error logs did reveal one potential problem though. I’ve had well over a thousand hits to invalid URLs like http://joshduck.com/perio. These are obviously URLs which have run up against Twitter’s infamous 140 character limit and have been truncated. This results in wasted traffic for me and a waste of time for my visitors so I decided to push a quick fix.

I was already redirecting 404′s to a custom PHP page, so I added a check which redirects anyone who gets a 404 after accessing a truncated URL to the correct page. To stop similar problems from happening in the future I’ve added a short script that looks at static pages and blog posts on my site and tries to match them against any the requested URL when serving a 404 page. These URLs are then used to display a list of suggested links to the user. The script also does a little regex magic (read: hackery) to find the titles of the suggested links. Now URLs like http://joshduck.com/photo or http://joshduck.com/blog/201 will give visitors a push in the right direction.

The actual script I use is specific to the code I use for my own site, but I’ve supplied a generic version of the script below.

<?php
$request_path = $_SERVER['REQUEST_URI'];
 
// Special case: redirect anyone trying to get to periodic-table.html straight there.
if (strlen($request_path) > 2 && strpos('/periodic-table.html', $request_path) === 0) {
	header('Location: /periodic-table.html');
	die();
}
 
// Check static files.
$suggestions = array();
foreach (glob('/*.html') as $file) {
	$url = '/' . $file;
	if (strpos($url, $request_path) === 0) {
		$content = file_get_contents($file);
		if (preg_match('/<title>([^<]+)/i', $content, $matches)) {
			$title = $matches[1];
		} else {
			$title = $url;
		}
		$suggestions[$url] = $title;	
	}
}

The function takes a string with string fragments marked up inline as its main argument. It then formats the output based on the count passed into the function.

function pluralize($text, $count = 0) {
	$regex = '/\[(.*?)\]/';
	$divider = '|';
 
	// If there are no end braces [] use whole input as option list.
	if (preg_match($regex, $text, $matches)) {
		$search = $matches[0];
		$fragments = explode($divider, $matches[1]);
	} else {
		$search = $text;
		$fragments = explode($divider, $text);
	}
 
	// We accept one (which is pointless...), two or three inline text fragments.
	// If we've been given just two then case for zero should be same as two or more.
	if (count($fragments) == 1) {
		$fragments = array($fragments[0], $fragments[0], $fragments[0]);
	} else if (count($fragments) == 2) {
		$fragments = array($fragments[1], $fragments[0], $fragments[1]);
	}
 
	// Normalize count.
	// If value is array then use the number of elements as count.
	if (intval($count) <= 0) {
		$count = 0;
	} else if (is_array($count)) {
		$count = count($count);
	} 
 
	// Choose the appropriate text fragment.
	if ($count <= 1) {
		$replace = $fragments[$count];
	} else {
		$replace = $fragments[2];
	}
 
	// Replace markup with chosen option.
	$text = str_replace($search, $replace, $text);
 
	// Place our count into output (allows user to put %d inline to get count).
	$text = str_replace('%d', number_format($count), $text);
 
	return $text;
}

The tests show example usage.

$input = "There [are no pages|is 1 page|are %d pages]";
assert(pluralize($input, 0) == 'There are no pages');
assert(pluralize($input, -1) == 'There are no pages');
assert(pluralize($input, 1) == 'There is 1 page');
assert(pluralize($input, 2) == 'There are 2 pages');
assert(pluralize($input, 1000) == 'There are 1,000 pages');
assert(pluralize($input, null) == 'There are no pages');
assert(pluralize($input, array(1, 2, 3)) == 'There are 3 pages');
 
$input = "1 page|%d pages";
assert(pluralize($input, 0) == '0 pages');
assert(pluralize($input, 1) == '1 page');

I am releasing this into the public domain so feel free to copy and redistribute the code.

I’ve worked with PHP for over six years. It has it’s warts (and how) but it’s very much a known quantity at this point. On the other hand, when I have used Python it’s been a much more pleasant experience. The fact that this is a personal project makes the decision easier: let’s ditch old mate LAMPhp go with LAMPy. It’s almost dinner time and the latter sounds like it’d go well with an ale anyway. So, starting with a brand new dev box, where do I begin?

1. Go to the Python website
   Of course. So P-Y-T-H-O-N-DOT-C-O-M, Enter. Er. Not exactly what I was looking for (and not what you should be looking for if your boss is anywhere nearby). Let’s try that again. Google to the rescue. Apparently I want DOT-O-R-G.
2. Choose a binary
   OK, so I know from listening to the fine folks over at proggit that there is an attempted Python 2 to 3 migration happening at the moment. There is no point investing my time in an outdated version so I’ll grab the 3.1 download.
3. Install Python
   C:\Python31. Hmm. Python, I know that you have a high opinion of yourself but you’re not that important to me just yet. You can go play nice in Program Files with all the other programs.
4. Download Django
   Now it’s Django’s turn. There’s the installer. Python 2.3 or higher, you say. Well logically 3 is higher than 2.3, but doesn’t Python 3 have problems with it’s younger siblings? Let me just check with a hit of the old Google… yup, as I thought. We’ll have to go with the older version.
5. Install Python
   Python 2! It’s not quite as fun when you know your downloading an outdated model.
6. Install Django
   So I’ve downloaded Django and now I’ve got an archive full of Python files. How do I install them?
7. Read the instructions
   But I hate doing that!
8. Run setup.py
   So I have to run the included setup.py file? If I launch the file from Explorer it prints something then immediately exits. Let’s open up the command line, cd to the correct location and run it again.
9. Run setup.py install
   OK, I forgot the “install” argument. You could have just told my with a popup; slept after printing the error; or heaven forbid, prompted me for an action. At least it’s working… can’t copy!? What do you mean?
10. Run setup.py install as an administrator
    Ah, of course you can’t copy to my Program Files. Time to launch a new command window as an administrator, renavigate to the archive and install.
11. Start a Django project
    You have to love the feeling you get when something works first time.
12. Define database settings
    Edit my project settings, easy enough.
13. Run the Django server
    Error: MySQLdb blah blah blah. What does that mean? Wait, Python does come with MySQL extensions right? Right!? It’s not like it’s one of the the most popular RDBMS on the planet.
14. Google it
    Hi Google. Yes, I’m back again. Do you know which module I want? Wow. That’s a lot of results. Are these the same? I’m looking for MySQLdb, not MySQL-Python. Ah, I see. They’re the same.
15. Go to SourceForge
    Why is this on SourceForge? Who’s distributing it? Ah, screw it. There is a big download button. I’m sure it’s safe. I mean, the button is green. Green is good. Red is bad. I didn’t get this far without learning a few things.
16. These are not the files you are looking for
    What do you mean they are the C files? I want a binary installer dammit. I’m a Windows user. I’m like a ten year old who still has training wheels on his bike; I don’t know anything about make files and building binaries.
17. Get the binary
    At least I know where the binaries can be downloaded… don’t I? Why do the binaries stop at Python 2.5 on the SourceForge page?
18. Google it!
    Yes, Google, I know I was just here. Just tell me where I can get a binary. Please stop laughing at me.
19. Download a binary
    There are a bunch of unofficial installers. Which one do I choose? bobs-super-awesome-mysql-python-for-2.6.exe looks reputable.
20. Install MySQLdb
    Great, a proper installer this time. It looks a bit “Windows 95″ but beggers can’t be choosers. At least with an installer this should be eas… Hmmm, it’s frozen.
21. Think back
    Wait, the other installer didn’t like running as a non-priviledged user. Perhaps if I run as root. Ah-ha. That’s done it.
22. Install Python
    How silly of me. It should be obvious that all the C extensions only offer win32 versions. What exactly is the point of having a 64 bit binary then? Let’s reinstall Python. Joy of joys.
23. Enjoy
    Success at last. Time to revel in my new found smugness as a Pythonista: “If the implementation is easy to explain, it may be a good idea.” You tell ‘em Guido.

The Takeaways

Sarcasm is fun! Fixing things is hard. Nevertheless, there are quite a few frustrating hurdles that face those new to Python and Django.

• If the .com variant of your website is a porn site then you have problems. Developers might know to go to the right site but think of clueless managers.
• The Python download page should spell out the benefits and drawbacks to each binary download. Be realistic. It’s better that the developer gets the version they need first time rather than having to come back later on for seconds, or thirds.
• It’s not the 90′s any more. It’s not acceptable to expect to be installed to C:\ root.
• I didn’t mention it in the article but Python doesn’t add itself to my PATH. Having to dig around in my computer settings to be able to easily run Python from the command line is a pain.
• Win64 has existed for a long time now. Shouldn’t it be supported by common modules?
• Installers should be aware of restrictions introduced by Vista’s UAC model. This is basic stuff. Hanging on install without displaying errors is not acceptable.
• The MySQL module should not be a second-class citizen maintained by some third party. If you want to poach PHP developers then you have to speak their language… er, database.
• Setup tools could be a lot friendlier by prompting the user for an operation if an argument is not provided.
• The Django download page should make it clear that Python 3 is not supported. Dropping backwards compatibility is not actually that common in other languages.

for CHANGED in $(svn status | sed "s/^.......//" | awk "/.\./"); do
    echo $CHANGED;
    ls -l "$CHANGED";
done | cat > changes.txt

The sed naively removes the first nine characters from the file status from the svn status output, which should just leave the file name.

The awk removes all files and paths without an extension – this was necessary because I later fed the output through ls, and I didn’t want any folder listings.

The cat allows me to direct the output to a file. If you aren’t piping to a file then you can omit that part.

Finally, ls -l shows the mtime of the file. To show the atime I could have used ls -lu, though the results of this were a little inconsistant for me (some times were after the mtime, which seemed counter-intuative). I used ls because I couldn’t seem to find a replacement for stat that was available on a vanilla Solaris install.

If you’re on a Linux box the following should work just as well (without trying to filter by extension):

for CHANGED in $(svn status | sed "s/^.......//"); do
   stat "$CHANGED";
done | cat > changes.txt

Of course, I’m still new to bash coding so if you have a script that simplifies this I’d love to hear about it.

• Read both Atom and RSS feeds.
• Easy initialisation and feed iteration (one line for each).
• Cache URL contents (default is 60 minutes).
• Graceful degradation: fail gracefully on errors (errors result in a 0 item feed which can be iterated through).
• Single XML implementation for leaner code (SimpleXML).

Firstly, my usage examples:

$feed = new Feed('http://www.example.com/feed.rss');
 
//Get items with next() or current()
echo $feed->next()->title;           // "Blog post 1"
echo $feed->next()->title;           // "Blog post 2"
echo $feed->current()->title;        // "Blog post 2"
 
//Feed data returned
echo $feed->current()->title;        // "Blog post 2"
echo $feed->current()->date;         // int(1265569159)
echo $feed->current()->description;  // "Lorem ipsum dolar..."
echo $feed->current()->link;         // "http://www.example.com/blog/2"
echo $feed->current()->image;        // "http://www.example.com/blog/images/2.jpg"
 
//Get multiple items in single call
foreach ($feed->find(3) as $item) {
	echo $item->title;               // "Blog post 3" "Blog post 4" "Blog post 5"
}
 
//Reset internal counter
echo $feed->reset();
echo $feed->next()->title;           // "Blog post 1"
 
//Get random items, without repeating
echo $feed->random()->title;         // "Blog post 4"
echo $feed->random()->title;         // "Blog post 1"
 
//Total number of items
echo $feed->count();                 // int(10)

The implementation is below. I failed on the single-class requirement, instead choosing to use the Template design pattern and break the actual XML DOM navigation out into a seperate class for each feed type. This keeps the overall design a lot cleaner.

<?php
/**
 * Simple reader for RSS and Atom feeds. 
 * Requires: SimpleXML, fopen_wrappers
 * Limitations: Not content encoding support. 
 * 
 * Usage:
 *     $feed = new Feed('http://www.example.com/feed.rss');
 *
 *     //Get items with next() or current()
 *     echo $feed->next()->title;           // "Blog post 1"
 *     echo $feed->next()->title;           // "Blog post 1"
 *     echo $feed->next()->title;           // "Blog post 2"
 *     echo $feed->current()->title;        // "Blog post 2"
 *
 *     //Feed data returned
 *     echo $feed->current()->title;        // "Blog post 2"
 *     echo $feed->current()->date;         // int(1265569159)
 *     echo $feed->current()->description;  // "Lorem ipsum dolar..."
 *     echo $feed->current()->link;         // "http://www.example.com/blog/2"
 *     echo $feed->current()->image;        // "http://www.example.com/blog/images/2.jpg"
 *
 *     //Get multiple items in single call
 *     foreach ($feed->find(3) as $item) {
 *         echo $item->title;               // "Blog post 3" "Blog post 4" "Blog post 5"
 *     }
 *
 *     //Reset internal counter
 *     echo $feed->reset();
 *     echo $feed->next()->title;           // "Blog post 1"
 *
 *     //Get random items, without repeating
 *     echo $feed->random()->title;         // "Blog post 4"
 *     echo $feed->random()->title;         // "Blog post 3"
 *
 *     //Total number of items
 *     echo $feed->count();                 // int(10)
 */
class Feed {
	private $url;
	private $reader;
	private $current;
	private $remaining;
 
	public $cacheTime = 3600;
 
	/**
	 * Create Atom reader object.
	 *
	 * @param string $url
	 */
	public function __construct($url) {
		$this->url = $url;
		$this->reset();
	}
 
	/**
	 * Reset current item to first RSS item.
	 */
	public function reset() {
		$this->current = -1;
		$this->remaining = null;
	}
 
	/**
	 * Get the next item in the feed.
	 *
	 * @return stdClass Object representing the item. Will return null when the list is exhausted.
	 */
	public function next() {
		if ($this->current < $this->count()) {
			$this->current++;
			$next = $this->getReader()->item($this->current);
			return $next;
		}
	}
 
	/**
	 * Get the current item in the feed.
	 *
	 * @return stdClass Object representing the item. Will return null when the list is exhausted.
	 */
	public function current() {
		return $this->getReader()->item(max(0, $this->current));
	}
 
	/**
	 * Get random item from the feed. Will not return an item more than once.
	 *
	 * @return stdClass Object representing the item. Will return null when the list is exhausted.
	 */
	public function random() {
		if ($this->remaining === null) {
			$this->remaining = array();
			for ($i = 0; $i < $this->count(); $i++) {
				$this->remaining[] = $i;
			}
		}
 
		if (count($this->remaining)) {
			$picked = array_rand($this->remaining);
			$index = $this->remaining[$picked];
			unset($this->remaining[$picked]);
			return $this->getReader()->item($index);
		}
	}
 
	/**
	 * Get X items from feed. Will advance pointer.
	 *
	 * @param int $count
	 * @return array of stdClass
	 */
	public function find($count) {
		$items = array();
 
		while ($item = $this->next()) {
			$items[] = $item;
			if (count($items) >= $count) {
				break;
			}
		}
 
		return $items;
	}
 
	/**
	 * Get the number of items in the feed.
	 *
	 * @return int
	 */
	public function count() {
		return $this->getReader()->count();
	}
 
	/**
	 * Get FeedReader object for the feed.
	 *
	 * @return FeedReader
	 */
	private function getReader() {
		if (!$this->reader) {
			$xml = $this->getXML();
			if (RSSReader::canRead($xml)) {
				$this->reader = new RSSReader($xml);
			} else if (AtomReader::canRead($xml)) {
				$this->reader = new AtomReader($xml);
			} else {
				$this->reader = new NullReader($xml);
			}
		}
		return $this->reader;
	}
 
	/**
	 * Get XML element for the feed.
	 *
	 * @return SimpleXMLElement
	 */
	private function getXML() {
		if ($xml = $this->getCacheXML()) {
			return $xml;
		} else if ($xml = $this->getURLXML()) {
			return $xml;
		} else {
			return new SimpleXMLElement("");
		}
	}
 
	/**
	 * Get XML element for the feed from cache.
	 *
	 * @return SimpleXMLElement or null if cache doesn't exist.
	 */
	private function getCacheXML() {
		//Store URL data in local cache.
		$cacheFilename = $this->getCacheFilename();
		if (file_exists($cacheFilename) &amp;&amp; (time() - filemtime($cacheFilename)) < $this->cacheTime) {
			if ($data = file_get_contents($cacheFilename)) {
				return new SimpleXMLElement($data);
			}
		}
	}
 
	/**
	 * Get XML element from the feed from the live URL.
	 * Will cache XML data to disk.
	 *
	 * @return SimpleXMLElement or null if URL is unreachable.
	 */
	private function getURLXML() {
		if ($data = @file_get_contents($this->url)) {
			try {
				$xml = new SimpleXMLElement($data);
				file_put_contents($this->getCacheFilename(), $data);
				return $xml;
			} catch (Exception $e) {
				return null;
			}
		}
	}
 
	/**
	 * Name of the cache file for current URL.
	 *
	 * @return string
	 */
	private function getCacheFilename() {
		return sys_get_temp_dir() . '/' . md5($this->url) . '.feed.cache';
	}
}
 
/**
 * Interface for reading items from feed.
 */
interface FeedReader {
 
	/**
	 * Create reader from SimpleXMLElement.
	 *
	 * @param SimpleXMLElement $root
	 */
	public function __construct(SimpleXMLElement $root);
 
	/**
	 * Get single node.
	 *
	 * @return array or null.
	 */
	public function item($index);
 
	/**
	 * Get number of items.
	 *
	 * @return int.
	 */
	public function count();
 
	/**
	 * Can this reader understand the XML file?
	 *
	 * @param SimpleXMLElement $root
	 * @return bool
	 */
	public static function canRead(SimpleXMLElement $root);
 
}
 
/**
 * Concrete implementation of FeedReader that will never return an item.
 */
class NullReader implements FeedReader {
 
	public function __construct(SimpleXMLElement $root) {
		//Nothing
	}
 
	public function count() {
		return null;
	}
 
	public function item($index) {
		return null;
	}
 
	public static function canRead(SimpleXMLElement $root) {
		return true;
	}
}
 
/**
 * Concrete implementation of FeedReader that will read an Atom feed.
 */
class AtomReader implements FeedReader {
 
	private $root;
 
	public function __construct(SimpleXMLElement $root) {
		$this->root = $root;
	}
 
	public function count() {
		return count($this->root->entry);
	}
 
	public function item($index) {
		$node = $this->root->entry[$index];
 
		if (!$node) {
			return null;
		}
 
		$item = array(
			'title' => (string)$node->title,
			'description' => (string)$node->description,
			'image' => null,
			'link' => null,
			'date' => strtotime($node->published),
		);
 
		//Iterate through link nodes getting content URL and images.
		foreach ($node->link as $link) {
			if (strpos($link['type'], 'text') === 0 || $item['link'] === null) {
				$item['link'] = (string)$link['href'];
			}
			if (strpos($link['type'], 'image') === 0) {
				$item['image'] = (string)$link['href'];
			}
		}
 
		return (object)$item;
	}
 
	public static function canRead(SimpleXMLElement $root) {
		//Check for Atom namespace.
		return in_array('http://www.w3.org/2005/Atom', $root->getNamespaces());
	}
}
 
/**
 * Concrete implementation of FeedReader that will read an RSS feed.
 */
class RSSReader implements FeedReader {
 
	private $root;
 
	public function __construct(SimpleXMLElement $root) {
		$this->root = $root;
	}
 
	public function count() {
		return count($this->root->channel->item);
	}
 
	public function item($index) {
		$node = $this->root->channel->item[$index];
 
		if (!$node) {
			return null;
		}
 
		return (object)array(
			'title' => (string)$node->title,
			'description' => (string)$node->description,
			'url' => (string)$node->link,
			'image' => null,
			'date' => strtotime($node->pubDate),
		);
	}
 
	public static function canRead(SimpleXMLElement $root) {
		//RSS feeds name their root node 'rss'.
		return $root->getName() == 'rss';
	}
}

There are a few things missing, namely any kind of encoding awareness and correct error handling. It also requires SimpleXML and allow_url_fopen to be enabled. On the plus side the code is simple enough to hack in new features as they are needed.

I’m releasing this code under the BSD License, so feel free to take and modify it for any purposes.

While my first, naive, assumptions were that Twitter was a simple read/write system that could be knocked up in a week, numerous people have pointed out the many challenges that the website faces. TechCrunch has revealed that Twitter handles 3 million messages a day, from 200,000 active users. Many people have pointed out the fact that some Twitter users have upwards of 30,000 followers, and are themselves following that number of members themselves. This lead to the general consensus that Twitter is really just a giant messaging system, not just your basic CRUD setup.

I found this conclusion to be a lot more insightful than the the usual “Rails sucks” arguments that are floating around. The view was echoed by a Twitter obsessed friend the other day who asked my opinion on how a hypothetical Twitter clone could be built. He was also of the opinion that the difficult part would be creating a robust messaging system to distribute messages to storage shards and other distribution systems (SMS and any other “push” delivery mechanisms). Viewed from that perspective, it becomes an interesting engineering challenge. I’m sure that a stable system could be built without too many problems.

Based on this line of thought I was pretty surprised to read today that Twitter is running on a single master MySQL database with just two slaves serving out reads. Ouch. If they ran smoothly then there would be no reason to doubt that the company know what they are doing. However, this is obviously not the case. Even more confusing is an old blog post in which Twitter developers reveal that their biggest problems occur when users with many followers post. I can’t really imagine what setup would account for that. It sounds like a denormalized database contained within a single physical server, which just sounds like lot of effort for little gain.

For a company that has just secured a second, $15 million, round of funding their performance is ridiculous. Out of a over a dozen staff they have only three or four tech guys. If I were investing I’d be asking what the hell is going on. I’m not trying to pretend that Twitter would be an easy fix, I don’t envy the engineers. They have to maintain their current (failing) product while simultaneously pushing to build a completely different system behind the scenes. I’ve been there, and it’s not fun. Apart from having to siphon off precious developer time to keep the old system patched up, they have to face the uphill task of rebuilding everything. Having a huge user-base makes this even more difficult, as they need to get this right first try. No one is going to be happy if an updated version falls over, drops features, or is any way inferior to what they have now. It wouldn’t be surprising to see the new version of their back end systems continuously delayed far into the future.

It should be interesting to see how and if Twitter recovers from all of this. The user base seems to have been fairly forgiving up until now. Even I signed up knowing all the problems they have. Having many bloggers shouting their praise wont hurt them much. Even the many complaints are free press, really. I doubt an stable Twitter would have been written up on TechCrunch quite so much. They do face the threat of someone stealing their glory though. Each day they have outages is a gift to the dozens of Twitter clones that are undoubtedly out there. Just think Friendster; I’m sure they’ll be stable any time now.