Perhaps I should be consoled by the fact that the reason I'm looking at these prior works now isn't because they broke in front of a customer. This time, at least.

However, this is what I've used in most scripts I've thrown together in the last few years – I hate having to throw a mysql_error call after every query, y'know?

<?php
 
define('CLIENT_LONG_PASSWORD', 1);
 
class MySQLWrapper
{
	var $server_port	=		'localhost:3306';
	var $database 		=		'whatever';
	var $username 		=		'a username';
	var $password 		=		'a password';
	var $force_long_password = false;
	var $db_object;
 
	function __construct($server_port = "", $database = "", $username = "", $password = "", $force_long_password = false)
	{
		$this->server_port = $server_port;
		$this->database = $database;
		$this->username = $username;
		$this->password = $password;
		$this->force_long_password = $force_long_password;
 
		if ($this->server_port != "")
		{
			$this->Connect();
		}
	}
 
	function Connect()
	{
		if (isset($this->db_object))
		{
			if (!mysql_ping($this->db_object))
			{
				unset($this->db_object);
				$this->Connect();
			}
		}
		else
		{
			$db_object = mysql_connect($this->server_port, $this->username, $this->password, false, $this->force_long_password ? CLIENT_LONG_PASSWORD : 0);
			if ($this->database != '' && !mysql_select_db($this->database))
			{
				$result = mysql_error();
				print "Select database failed for $this->database: $result\n";
			}
		}
	}
 
	function Disconnect()
	{
		$return = true;
 
		if (isset($this->db_object))
		{
			$return = mysql_close($this->db_object);
			unset($this->db_object);
		}
 
		return $return;
	}
 
	function Execute($query)
	{
		$this->Connect();
		$result = mysql_query($query);
		if (!$result)
		{
			$result = mysql_error();
			print "Query failed: $result\n";
			print "Teh query itself: $query\n";
		}
		return $result;
	}
}
 
?>

You may find this slightly better than using PHP's MySQL functions straight out of the box. Or not. Who can say?

I don't even know why I felt like writing this.

This script will keep a certain percentage of the tables in your MySQL database locked. It will lock the first N% of your database, and then move forward one table at a time, locking the next table in line and releasing the lock on the one at the end of the tail.

Why would someone use this script? For benchmarking some completely unrealistic scenario? To decrease database efficiency for no good reason? Who can say.

Note: you'll get to lock/release tables a lot more quickly if you run this script locally.

<?php
 
$percentage_of_database_to_lock = .25;
 
require('./shared/mysql.php');
 
$mysql = new MySQLWrapper();
$mysql->server_port = 'host:3306';
$mysql->database = 'some_db';
$mysql->username = 'some_user';
$mysql->password = 'some_pass';
 
$res = $mysql->Execute('SHOW TABLES');
 
$tables = array();
 
if ($res)
{
	while ($row = mysql_fetch_array($res))
	{
		$tables[] = $row[0];
	}
}
 
$tables_to_lock = floor($percentage_of_database_to_lock * count($tables));
 
if ($tables_to_lock > 1)
{
	$cycles = 0;
	$start_at = 0;
 
	while (true)
	{
		$query = 'LOCK TABLE';
		$tables_so_far = 0;
 
		while ($tables_so_far < $tables_to_lock)
		{
			$next_index = $start_at + $tables_so_far;
			if($next_index >= count($tables))
			{
				$next_index = $next_index - count($tables);
			}
 
			$query .= '`' . $tables[$next_index] . '` WRITE, ';
			$tables_so_far++;
		}
 
		$query = substr($query, 0, strlen($query) - 2);
 
		$mysql->Execute($query);
 
		$start_at++;
 
		if ($start_at > count($tables))
		{
			$start_at = 0;
			print "Cycle " . ++$cycles . "\n";
		}
	}
}
 
?>

Dependencies: MySQLWrapper

I decided to open up by looking for traditional profanities – a commonly-accepted method of gauging the state of a project (see: profanities in the Linux kernel, graphed over time and a quick look at the Win2k source).

Below, I provide a list of my findings, with a few examples. Enjoy a look at the source code of a functioning product with many users!

Disclaimer: if any of the words that you are about to read will offend you, then don't read them.

The classics

I started off by looking for looking for the current English classics:

Fuck: 6 times.
Example:

// If they had any unsaved changes, they're pretty much fucked, because
// this customer has apparently been modified by another screen.

Shit: 10

// For now, I believe that all the data is updated on the fly, so saving first is not
// necessary, but maybe we should just for shits and giggles

Crap: 22
The expletive for the more vocabulary-sensitive programmer!

//!!! It was late, we were tired, so I hacked this crap together !!!

// What the crap does this button do? - I disabled it because I think that this button
// is misleading and confusing

Hell: 1

// If it wasn't any of the valid options, then get the hell out

Insults

It's usually another programmer's fault.

Stupid: 75
The code is stupid, the users are stupid, other developers are stupid. According to the comments, at least.

// Clear out year if it is a stupid number

// Here we tell the user they are stupid when they do stupid things
// If the user forgets to specify a table, gently remind them that it's a good idea,
// then return

// When you minimize, it tells you you're size 0 now.  That seems stupid, ignore it

// Die, stupid message boxes

TRACE("Stupid quickbooks.\n");

IQBBasePtr stupid = response->GetDetail();
TRACE("Response Type: %d\n", (int)stupid->Type->GetValue());
InterpretResponse(stupid);

// Thigs are different (stupid) without this flag.  I don't currently support its omission

Dumb: 17

// There was some seriously wacky code here earlier including a really dumb memory leak.
// I tested my changes and they seem to work fine, nevertheless, I wasn't able
// to fully understand what this code was attempting to do so I may have missed
// some obscure feature.

Retarded: 4

// Because CStrings are retarded and don't do well with binary data, we have to copy the
// data in to the query in a rather inconvenient manner.

Idiot: 2

// Else politely inform the user that they are an idiot

Hack: 6

// Look at the first part of the label to find the operation (this is a sort of
// dirty hack so that) we don't have to change the database.

Incredulity

Really?

Why: 84
The only word with a higher count than "stupid" – there is always more for a programmer to learn. Or speculate on. Or rage at.

//!!! For some reason ODBC crashes at this point if you've already done a query !!!
//!!! I can't really figure out why !!!

// Not sure why we would want to do bitwise operations...

// WHy doesn't this exist?

// I don't see why we'd do this

// CRH asks: Why do we use Format() instead of "="? Can't we assume that it's slower?
// JDD Answers: what Formats?  What are you talking about?  You crazy, Charles!

// Removed 2006.02.17 - This makes it so that negative balances show up positive.
// I am not sure sure why it was ever here.

// This doesn't seem to work.  I'm not sure why

wtf: 25
Often heard expressed verbally by developers reading code.

catch (...)
{
	TRACE("Seriously, wtf\n");
	// sic vita est
}

// Sort the incoming files alphabetically (windows sometimes reverses the order (wtf?)

Random

Ridiculous: 2
When three syllables just isn't enough.

// Make the quantity not have ridiculous decimal places

Pants: 3
That's right, and all 3 times inside of a static string, too!

strPCProductCode = GetInitSetting(__MASTERWND, "session", "productcode", "pants");

That fourth argument is the default value, returned if there is no existing setting with that name. So… yeah.

lol: 3

// lol xor
if ((bPaid || bUnpaid) && !(bPaid && bUnpaid))

lulz: 1

// Half implemented, lulz

A few other gems

Ebonics?

// If shift was already depressed, fo' real, don't screw that up

Obvious mental deterioration:

// A grape typed this line in:
//9

And… uh… this was at the bottom of a header file…

// Standardized code makes him happy!
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;;        ;;;;;;;;        ;;
;;       ;;      ;;       ;;
;;      ;; ;;  ;; ;;      ;;
;;      ;;        ;;      ;;
;;      ;;    ;   ;;      ;;
;;      ;;        ;;      ;;
;;      ;; ;;;;;; ;;      ;;
;;       ;;  ;;  ;;       ;;
;;        ;;;;;;;;        ;;
;;                        ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

// Non-Standardized code makes him sad!
// And keeps him up all night, screaming
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;;        ;;;;;;;;        ;;
;;       ;;;    ;;;       ;;
;;      ;; /*\/*\ ;;      ;;
;;      ;; \_/\_/ ;;      ;;
;;      ;;   ^^   ;;      ;;
;;      ;; /****\ ;;      ;;
;;      ;; \****/ ;;      ;;
;;       ;;      ;;       ;;
;;        ;;;;;;;;        ;;
;;                        ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

8-|

So, yeah…

Found any entertaining metadata in code?  Link me!

No?

Well, how about something like CHECK or REPAIR table, then?

If you ever find yourself in the rare situation where you need to run the same query across every table in a database, this procedure might make your life easier:

DELIMITER $$
CREATE PROCEDURE `p_run_for_each_table`(IN strDatabase TEXT, IN strOperation TEXT)
    DETERMINISTIC
BEGIN
	DECLARE strQuery TEXT;
	DECLARE strTable VARCHAR(255);
	DECLARE bDone INT DEFAULT 0;
	DECLARE TableCursor CURSOR FOR
		SELECT `TABLE_NAME`
		FROM `information_schema`.`TABLES`
		WHERE `TABLE_SCHEMA` = strDatabase AND TABLE_TYPE = 'BASE TABLE';
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET bDone = 1;
 
	OPEN TableCursor;
 
	REPEAT
		FETCH TableCursor INTO strTable;
 
		SET @QueryThatWasPassedIn := REPLACE(
			REPLACE(strOperation, '{?database}', strDatabase)
			, '{?table}', strTable);
 
		PREPARE Statement FROM @QueryThatWasPassedIn;
		EXECUTE Statement;
	UNTIL bDone END REPEAT;
 
	CLOSE TableCursor;
	DEALLOCATE PREPARE Statement;
END$$
DELIMITER ;

Useage

The procedure takes two parameters. The first one is the name of the database whose tables you want to run the query for.

The second is the query you would like to run. The strings "{?database}" and "{?table}" will be replaced with the database and table names.

CALL p_run_for_each_table('databasename', 'SELECT * FROM {?database}.{?table}');

What queries you can run

You should be able to use any queries that can be run in a prepared statement – you can find the list about two-thirds of the way down this page.

As of MySQL 5.1, you can run these queries: "ALTER TABLE, CALL, COMMIT, CREATE INDEX, CREATE TABLE, DELETE, DO, DROP INDEX, DROP TABLE, INSERT, RENAME TABLE, REPLACE, SELECT, SET, UPDATE, and most SHOW statements."

One particular error that I've seen time and time again (even from people who have been writing queries for a while) can occur when summarizing data from multiple tables that have a one-to-many relationship.

…In other words, it could occur in queries written for most database-driven software.

Solution: fix the problem by writing about it!

I wrote a page documenting the cause of the logical error, doing my best to warn people against letting it slip into their own code.

I attempted to write it so it would be easy to read, possibly even entertaining (a lofty goal for a manual on writing database queries, perhaps) – there is some colorful language and plenty of juvenile humor mixed with the tech-speak.

The doc itself is part of the wiki of the company where I work. I don't write a ton of documentation for our developers or customers (certainly not as much as I should), but whenever I do, I get this awesome feeling of usefulness. Oh, and pride. Sometimes, I feel so proud, that I feel compelled to link other people (who have no relationship to my company) to what I wrote! Ridiculous, I know.

Remember: if you write queries, it is your responsibility to guarantee that they return true and accurate data!

The other day a coworker was looking to beautify a large quantity of data spread across some MySQL tables.  I created this function to make his life easier:

DELIMITER $$
CREATE FUNCTION `f_sentence_case`(strInput TEXT, nMinimumLength INT) RETURNS TEXT
DETERMINISTIC
BEGIN
 
	DECLARE result TEXT;
	DECLARE LastSpace INT;
	DECLARE NextSpace INT;
	DECLARE NextSlash INT;
	DECLARE Word TEXT;
	DECLARE NewSentence INT;
	DECLARE PreviousCharacter CHAR(1);
	DECLARE TrimmedWord TEXT;
	DECLARE NumberOfSpaces INT;
	DECLARE Swap INT;
 
	SET strInput := CONCAT(strInput, ' ');
	SET result := '';
	SET LastSpace := 1;
	SET NextSpace := LOCATE(' ', strInput, LastSpace + 1);
	SET NextSlash := LOCATE('/', strInput, LastSpace + 1);
 
	SET NextSpace := IF(LEAST(NextSlash, NextSpace) = 0, GREATEST(NextSlash, NextSpace), LEAST(NextSlash, NextSpace));
 
	label1: WHILE NextSpace DO
 
		SET Word := SUBSTR(strInput, LastSpace, NextSpace - LastSpace);
		SET PreviousCharacter := SUBSTR(strInput, LastSpace - 1, 1);
		SET NewSentence := LastSpace = 1 OR (NewSentence AND PreviousCharacter = ' ') OR PreviousCharacter IN('.', '!', '?');
 
		SET TrimmedWord := LTRIM(Word);
		SET NumberOfSpaces := LENGTH(Word) - LENGTH(TrimmedWord);
		SET Word := TrimmedWord;
 
		# Make it lowercase if it is all uppercase
		SET Word := IF(LENGTH(Word) >= nMinimumLength AND Word NOT REGEXP '[0-9]', 
			IF(NewSentence,
				CONCAT(UCASE(SUBSTR(Word, 1, 1)), LCASE(SUBSTR(Word, 2, LENGTH(Word) - 1))),
				LCASE(Word)
			), 
			Word);
 
		SET result := CONCAT(result, REPEAT(' ', NumberOfSpaces), Word);
 
		SET Swap := LastSpace;
		SET LastSpace := NextSpace;
		SET NextSpace := LOCATE(' ', strInput, Swap + 1);
		SET NextSlash := LOCATE('/', strInput, Swap + 1);
		SET NextSpace := IF(LEAST(NextSlash, NextSpace) = 0, GREATEST(NextSlash, NextSpace), LEAST(NextSlash, NextSpace));
 
	END WHILE label1;
 
RETURN result;
 
END$$
DELIMITER ;

What it does

It seems to perform generally as I hoped it would; which is to say that it formats text to be sentence case.

More specifically, it alters all the "words" (a set of non-numeric, non-whitespace characters) that are longer than the specified minimum length.

It changes the words to be all lowercase, unless they happen to be the first word after a punctuation mark (in which case the first character of the word is made uppercase).

Useage

To clean up a field so that it is formatted in sentence case (ignoring all words with less than 3 characters), simply run this query:

UPDATE `table` SET `field` = f_sentence_case(`field`, 3);

Other than that, my only specs for the query were for it to be functional and hopefully not break my brain when I went back to read it later. If anyone has any significant improvements to it, let me know!

I wanted a fun campaign (duh) with rules and story that would be hard for me to mess up.  For most of the campaign, the only players were two good friends with solid role-playing experience, so I was able to rely on the players to contribute a good amount of quality.

The story

I took a stab at running an old-west campaign, borrowing every western-movie trope I could think of.  The PCs played gunslinging lawmen for hire, riding into a town oppressed by a gang of n'er-do-wells populated with plenty of tobacco-spitting, expendable, no-good outlaws to gun down.

Without going into too much detail: the players cleaned out a counterfeiting operation in an old widow's basement, were recruited to clean up the town, used aggressive negotiations to get rid of gang members harassing the mayor's house, and stopped another group of enforcers who were coercing money from some water-starved farmers.

Back in town, they took over the town prison, had a gun fight in a booby-trapped house, escaped just as it blew sky high, confronted the aristocratic gang leader on the porch of his ranch house, and finished with a gun battle on main street.

The system

At the recommendation of an experienced GM, I used the Boot Hill (second edition) rules, a creation of Gary Gygax and Brian Blume.

I was looking for super-lightweight rules, so I didn't even use the full rules set described by the Boot Hill book – the only dice rolling during the campaign happened during combat.  Boot Hill gun combat is simple:

• The fastest draw (based on weapon speed and personal speed) goes first
• Roll percentile dice (based on your weapon, personal accuracy, and a relatively short list of modifiers) to see if you hit:

• Roll percentile dice on a wound chart to see where you hit:

Mortal wounds kill you.

Any wound at all gives you a -5% chance at getting to shoot first, and also to hitting the other guy.

Once your strength drops below 50% of what it is normally (which can often be done with a single serious wound), you start getting -20% to shooting first, and hitting.

It's a simple system, but one that facilitates characters dying pretty often.  A couple good rolls, and a single shot can permanently take out any character – even if he just rolled into town with a new bandanna and a pocket full of hit points.

Wait, easy character death?

I wanted my players to enjoy a good old-fashioned movie version of the wild west.  They were supposed to play the heroes – the guys who go flying through bar windows and come up swinging!

I wanted quick and dirty combat, but I wanted my PCs to be a bit more survivable.  I tried a few things to counteract the cheapness of life:

Giving the PCs slightly better stats

Standard nerfing – most of my NPCs would drop below half strength after one serious wound (which severely limits a character for the rest of the combat).  The player characters could took at least two (non-mortal) wounds before things got really sticky.

Making healing much more trivial than the rules suggested

According to the rules, healing is a fairly slow process, taking days or weeks to recover from any sort of combat wound.  My player characters needed to be able to get into gun battles every few hours – they could be rejuvenated by a good night's sleep, or the restorative powers of a kindly old lady's stew.

Adding a new game mechanic

I decided to take a hint from the awesome and successful video game Left 4 Dead.  In that universe, survivor characters who go down are immobilized, but can still fire handguns until their teammates pull them up (or the zombies fill up at the brain buffet).

Any time one of the PCs took mortal damage, I did something similar – instead of the characters dying, they dropped to the ground and could fire their handguns at a reduced rate.  If another player made it over to them and used a round to pull them up, that character could enter the fray with some of their strength restored.

It wasn't a mechanic that saw a lot of use, but it turned several potential defeats into narrow victories.  I was happy with this – narrowly beating the baddies is a lot more exhilarating than seeing one side gun down the other like dogs.

Also, I'm a noob

I found it a highly enjoyable experience, but there were weak spots.  The campaign was fairly light on dialog, which isn't necessarily a bad thing – I just wish I were better at having a conversation in character, and thinking on my feet.

My weaknesses were most evident in the final session, where my PCs held the big baddy in prison and were looking around for a way to prove his guilt (they were lawful, after all) or uncover the next plot hook.

I left them wandering around looking for a clue far too long before I initiated the next action for them to deal with.  They grilled the prisoner for some time (good roleplaying, at least), looking for the magic words that would advance the plot.  Blah.

I think I might try this again

I was very glad to have such great (and forgiving) roleplayers in my campaign.  When the GM is fresh, there's a lot less room for noobs or troublemakers.

I'm definitely sold on lightweight rules sets, especially when going for a more cinematic feel.  The less of a barrier there is between the players and the cool things they want their characters to do, the better.

I have a suspicion that we might try this (noobs GMs practicing with friends) again sometime soon – if you have any suggestions for easy-to-pick-up gaming systems, or good scenarios for some one-shot sessions, then surrender your knowledge to my gaping mind-hole!

However, I'm still not a big fan of it when it comes to seeing other people's content.

The problem

Facebook shoves too much information down my throat, even if it's about people I care for.

The way it works on the rest of the internet

The things that you can post on Facebook (blog posts/notes, status updates, photo albums, sharing links) can all be released on other services.

Other people can subscribe to each of those sites individually – if someone posts interesting status updates, I follow them on Twitter.  If they take cool pictures or write insightful blog posts, I add those respective feeds to my RSS reader.

I follow only the things I am interested in – and because I can be picky about what I follow, I end up reading everything that comes through those feeds.

Facebook doesn't let me choose

The recent Facebook update gives the content providers (you and your friends) control over who CAN see certain information.  This is definitely useful, and I appreciate it.

But I don't get many options about what information I see in my news feed – if someone else publishes information to their feed, my only options are to

• Block ALL information from that user, and not see anything they post
• See every single thing they publish to their feed
• In the case of third-party apps, I could block the application and not see any information from that app, for any user.

If I have a friend who makes really funny status updates and posts a ton of photos to their Facebook album, it's all or nothing for me – Facebook doesn't let me select what I'm interested in seeing from the other user.

As a result, my Facebook feed is full of information ranging from interesting content to wastes of pixels.

I don't roll that way

I consume a lot of information over the internet – My feed reader tracks over 150 feeds the last time I checked, and I follow over 100 people on Twitter.  And I read almost every piece of information that comes through those feeds!

I can do this because I am picky about what I follow.  If I'm not sure that at least 95% of the posts in a feed are going to be interesting to me, I don't follow it.

If a blogger, Twitter user, or photo album is publishing more than a few new items per day, I don't follow it (no matter how interesting it is) because my feed reader would get too cluttered, too quickly.  I wouldn't be able to keep up.

It's not the fault of my friends

Well, not most of them, anyway.  Some of them do post really stupid stuff to their feeds.  But I can block those users without feeling bad.

Let's say I take pictures of local scenery fairly often, and upload them to Facebook photo albums.  Facebook photo permissions are set per-album – I would probably have an album set up to be publicly viewable to everyone (because why wouldn't I share those pictures with whoever was interested?).

Now, when I upload the pictures, I have an option to share them with people.  When I do this, the photo will show up in their feed (unless they've blocked me).

At this point, the responsibility is all on me – which of my friends would be interested in a photo of a sunrise just starting to brighten O street? I can share it with a specific group of people – maybe I even set up a list of people who I know like photography, and only post the new pictures into their feeds.

But those people don't get any say in the matter – if I post my new photos in the feeds of everyone on my friends list (which is the way Facebook has worked historically, and still acts by default), then those photos will be cluttering up their feed.

And if I try to be considerate, and only announce my newly discovered art to the few people I think would be most interested, then other people could be missing out – if I have friends who are actually interested in these photos, but I am not aware, I could very easily leave them out of the loop. And there's nothing they can do about it.

Facebook really wants to keep people happy

They're trying so hard to give people the tools they need to share their information reasonably.

I can understand why they're making the security so granular (so much so that it's getting really confusing to administrate) – security is something that almost everyone is concerned with, and a small group of people complain VERY loudly about.

But there's more to social networking than security

For people who care about the information they consume (and want to consume as much as possible), security settings do nothing.  They don't even matter.

If I'm not allowed to see someone's photo album, I don't care in the slightest – the only thing I do care about is whether or not I can filter the information that IS available to me, so that I only see things that are guaranteed to be worth my time.

And until Facebook lets me do that, there's no reason to consider using it as one of my primary social networking tools.

What did they do?

Facebook users get more choices about who will see the content they put online.  Here are my current settings:

However, there are still some catches – third party applications have the ability to see all the users who you are currently friends with, and you can't do anything about it.

Facebook used to be way lamer

Until this change, Facebook wasn't (in my mind) a great place for me to put content on the internet.

When you're sharing information of any sort with other people, there are a few things you should take into account:

You don't always want everyone to know

Having trouble with the spouse?  Angry with your boss?  It's natural to look for a shoulder to cry on, but you really shouldn't be sharing those sorts of details with just anyone.

There are entire web sites devoted to making fun of people who posted private or embarrassing information for all their Facebook acquaintances to see.  If you're wise, you keep those sorts of things to yourself.

You might want EVERYONE to know

Maybe you added a hilarious caption to a picture of a cat – maybe you wrote an eloquent post exposing the truth about that one professor everybody likes.  There are some things that just need to be shared with the world, you know?

In the past, Facebook was not the place for such coolness – that witty status update would only ever be seen by people who knew you in some fashion.

Not everyone cares

My Facebook status updates are currently pulled straight from my Twitter feed.  I try to make posts that have some kernel of interest to people with similar interests to mine – even if they don't know me personally.

This results in a lot of status updates that are confusing or uninteresting to people who actually are my friends – my mother really doesn't care if I'm looking for someone to play L4D2 with (let alone know what it stands for).

In the interest of keeping my status feeds accessible, I also avoid posting things with a limited appeal.  I could announce every new band I discovered, but few people would actually care.

As an aside, I've noted that most Facebook users seem to have no concept of this – they post any update that occurs to them, regardless of how little I may care.  (The nerve of some people, right?)

Facebook finally reflects reality

If you're one of those responsible people who are conscious about your audience when you say things on the internet, Facebook is now a lot more attractive.  Now, everything you add on that site can be filtered based on whether or not you want certain people to see it.

Until now, these aforementioned responsible people have generally taken this content elsewhere – either to a public site, where people who are interested in your content voluntarily choose to follow it, or by taking their private conversations to email or private chats.

It's especially important that certain information be public

I don't personally care that my friend list is publicly available to anyone who writes an application that accesses Facebook – though on principle, I am annoyed that there is no option to keep that private.

I do understand why Facebook would want to make this sort of information available to outside sources, though.

Other people can do useful things with that information

Since it's popularity explosion, Twitter's web site has had a pretty small feature set.  You could make posts, pick people to follow, and access other people's posts and follow lists.  You could even pick some posts to be your favorite posts – but not a lot else.

But Twitter has become highly popular (particularly to the nerdy crowd), in part because:

• Almost all the information is public – very few people choose to make their profiles private
• All of that public information is easily accessible to anyone

Anyone can write a handy application or web site that does something cool with the information people put on Twitter.  You have access to things people have said, and the the things that they're interested in seeing.

If you're the sort of person who likes to derive a useful meaning from large quantities of information, Twitter is a dream come true.

I haven't looked into Facebook's API at all – I don't know how simple it is to access information as a programmer.  But as a developer, having access to more information instantly makes Facebook more attractive to me when I'm looking to write an application to analyze the differences between high school cliques and college cliques (or whatever).

Facebook wants to be the definitive social network – but for some time, Twitter has been the most attractive place to get social networking data from.  I can see why Facebook wants to draw the line where they have, and I don't blame them.