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!

In some issue of Maxim (November 2005?) there was an article featuring absurd sandwich-based foods.  So ridiculous were these edibles that some fraternity brothers of mine decided that the consumption of one such sandwich would make a fitting end-of-semester celebration.

I was unable to find the original article online, but found the ingredients here.  I post them here for posterity.

The Dirty Mother

"Use two slices of buttery Texas toast as bookends, and slap together a sausage patty, hash browns, and three generous chops of ham, separating each layer with a slice of cheddar cheese. Throw two fried eggs in the mix, and comfort them with four strips of crispy bacon. A splash of ketchup or Worcestershire sauce is your choice, but tons of S&P is mandatory."

We would usually go to IHOP, order the ingredients individually, and assemble the sandwiches ourselves.  The braver souls in the group would purchase fries as a side dish.

These memories are making me hungry.

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!

That is to say, I did not sleep when it was dark – I slept when I felt tired enough to do so.  This happened to occur less often than nighttime.  To see a similar sleep schedule displayed in a handy timeline, check out this XKCD comic.

Over Christmas weekend (4 days), I tried the same thing – I fell asleep very late the evening of the first day, very early the morning of third day, and again the afternoon of the fourth day.

This is the end of that experiment – over 4 days, I have slept 3 times.  As I go to work right now, I have already been awake for 8 hours.  I will probably feel like sleeping not long after I leave work.

The odd sleep schedule has some benefits: it's not hard to fall asleep (because my bed time is defined by when I feel sleepy), and depending on my sleep patterns, there is the possibility of actually spending less time sleeping every week.

The abnormal waking hours definitely felt odd at times, though I feel that I started to get used to them a bit.  I'm considering trying a similar schedule over the course of a work week some time.  If I do, I will report back with my findings.