I don't feel comfortable
The air left the room a long time ago
All eyes are on me
Well, if you must know

I want a girl who reads
Yeah. Reads.
I'm not trying to call you a chauvinist
Cos I know you're not alone in this
but...

I want a girl who reads
Who needs the written word
& uses the added vocabulary
She gleans from novels and poetry
To hold lively conversation
In a range of social situations

I want a girl who reads
Who's heart bleeds at the words of Graham Greene
Or even Heat magazine
Who'll tie back her hair while reading Jane Eyre
and goes cover to cover with each waterstones three for two offer
but I want a girl who doesn't stop there

I want a girl who reads
Who feeds her addiction for fiction
With unusual poems and plays
That she hunts out in crooked bookshops for days and days and days
She'll sit addicted at breakfast, soaking up the back of the conflakes box
And the information she gets from what she reads makes her a total fox
Cos she's interesting & unique
& her theories make me go weak at the knees

I want a girl who reads

A girl who's eyes will analyse
The menu over dinner
Who'll use what she learns to kick my ass in arguments
so she always ends the winner
But she'll still be sweet and she'll still be flirty
Cos she loves the classics and the classics are dirty
So late at night she'd always have me in a stupor
As she paraphrases the raunchier moments from the works of Jilly Cooper

See, some guys prefer asses
Some prefer tits
And I'm not saying that I don't like those bits
But what's more important
What supercedes
For me
Is a girl a with passion, wit and dreams
So I want a girl who reads

Download

One of my least favourite things in life is converting between units of measurement, especially when cooking. All my mum’s recipes use imperial units, you see, yet my kitchen’s supply of measuring widgets is exclusively metric. Constantly launching a web browser and running the conversion through Google is just tiresome — but having just made the switch from Quicksilver to Alfred, I decided to have a go at building an Alfred Extension to do quick unit conversions using Google’s calculator API.

To use it, download the extension and install it via Alfred’s preferences window. Summon Alfred as usual, then make unit conversions with:

convert AMOUNT UNIT to UNIT

It can handle anything Google knows about, so queries like

• “convert 500 grams to lbs”
• “convert 375 fahrenheit to celsius”
• “convert 2 cups to liters”

will work just fine. For brevity’s sake, you can omit the ‘to’. Happy trans-cultural baking!

class Foo {
private:
  int value;
public:
  void setValue(int v);
  int getValue();
};

void Foo::setValue(int v)
{
    this->value = v;
}

int Foo::getValue()
{
    return this->value;
}

Suppose we also have (somewhere else) an instance of Foo:

Foo *aFoo = new Foo();

Trick question: what’s returned by aFoo->getValue(); at this point?

Instances of Foo can’t do much, but they can hold integer values. Here’s how we set/access the value property of a Foo instance:

aFoo->setValue(10);
std::cout << aFoo->getValue() << std::endl;

Instances of class Foo have two methods: getValue() and setValue(int). The semantics of these methods happen to involve manipulating the (private) property value, but they’re fundamentally no different than any other methods. If we don’t care about encapsulating the value property (you’re familiar with this concept, yes?) we could just as easily design Foo as:

class Foo {
public:
  int value;

  Foo(int v);
};

and set/access the value property with:

aFoo->value = 10;
std::cout << aFoo->value << std::endl;

This is perfectly valid, and often OK. So why have the so-called ‘getter and setter’ methods at all? They let us impose constraints on the value property. For instance, we might want to ensure that instances of Foo can only hold even-numbered values, and that, while they may store negative values internally, we should always expose a positive value. We can’t have constraints like that using public properties; instead, we restrict access to the value property (making it private) and ensure that all access we do allow goes through controlled methods (getValue() and setValue()):

void Foo::setValue(int v)
{
    // Ensure the new value is always an even number, setting
    // it to `v-1` if it is odd.
    this->value = v - (v%2);
}

int Foo::getValue()
{
    // Ensure that, regardless of the sign of `value` we always 
    // return a positive number (i.e. the absolute value of `value`).
    if (this->value < 0) {
        return -this->value;
    } else {
        return this->value;
    }
}

My usual workflow for research-oriented coding involves prototyping a tool or model in Ruby (fast to write, easy to understand), then porting the final, working version into C for use with real data (my models are usually trained on massive statistical corpora, something Ruby is, unfortunately, ill-equipped to handle). This is all well and good, but I always miss the usability that I can so easily sprinkle into the Ruby version. OptionParser is one such gem; Ruby/ProgressBar is another.

In a moment of frustration, I re-implemented Ruby/ProgressBar in pure, unadulterated C99. If you’re interested in that sort of thing, you can grab a copy from my GitHub repository:

git clone git@github.com:doches/progressbar.git

For comparison, here is how you use a progressbar in Ruby:

require 'rubygems'
require 'progressbar'

progress = ProgressBar.new("Loading",100)
(0..99).each do |i| 
  # Do some stuff
  progress.inc
end
progress.finish

…and in C:

#include "progressbar.h"

progressbar *progress = progressbar_new("Loading",100);
for(int i=0;i<100;i++) {
  // Do some stuff
  progressbar_inc(progress);
}
progressbar_finish(progress);

More examples, including custom formatting and indeterminate progress, are in test/progressbar_demo.c.

Fountain, T. & Lapata, M. (2010). Meaning Representation in Natural Language Categories. In S. Ohlsson & R. Catrambone (Eds.), Proceedings of the 32nd Annual Conference of the Cognitive Science Society. Austin, TX: Cognitive Science Society.

Squee.

The work I presented deals with whether corpus co-occurrence can be used as a stand-in for norming data, at least in the context of a categorization task; as part of that work I collected a rather large amount of data that I am now making publicly available. The dataset extends the McRae et al feature norms by grouping the words in forty-one categories, and includes norming data, integrated into the standard McRae features, for each of the newly-added category labels.

Fun stuff.

On the upside, running your own code on the iPhone is really cool — I haven’t felt this much like I was “hacking” (in the classical sense of the term) in a long time. The upshot of it all is that I’ve just released my first game, Levelheaded, for the iPhone. It’s a port of my old Global Game Jam project from last year, Jarhead, updated for the iPhone’s touch input and limited screen real estate. Now, onward with the marketing!

The code is hosted on GitHub; I’d appreciate a comment if you’re using the Sugar, just to help keep me motivated to work on the thing. Similarly, if you feel like contributing I’d love to accept patches or pull requests.

Naturally, this last bit is what really got me hooked. Espresso plugins are called ‘Sugars’, and can provide truly ludicrous extensions to the editor. Want to add a syntax highlighter for a new language? Specialized code folding for a certain coding idiom? Autocomplete and suggestion tools for a library? You can do it, and (almost) entirely in XML. Beautiful.

The first thing I did after downloading the trial version was hunt around for relevant Sugars, which I found to be somewhat sparse. Espresso is, unfortunately, quite a young editor. For instance, I couldn’t find a Sugar for working with configuration files produced/read by Python’s ConfigParser module — something I desperately need for a super-secret project I’m working on. Several hours of reading, writing, and frantic github searching later, I present:

ConfigParser.sugar

An Espresso Sugar providing syntax highlighting for configuration files layed out according to RFC 822. Among other things, it understands Windows .ini files and config files produced by Python’s ConfigParser module.

Installation

Clone the Github project somewhere, with the following:

git clone git://github.com/doches/ConfigParser.sugar.git ./ConfigParser.sugar

And then link it to your syntaxes directory:

ln -s "$(pwd)/ConfigParser.sugar" "/Users/$(whoami)/Library/Application Support/Espresso/Sugars/"

Actionscript 3 is fantastic. Flixel is beautiful.

Last weekend I thought I’d try it again, and got myself immersed in building another simple game, a little avoidance game where you navigate a ship through a cluttered trench. Owing to (unfortunate) science-related obligations, I had to put it away for the week — but a few hours of polishing menus and hacking audio this afternoon brought it up to something like a completed state. It’s nothing special, but you can play Trench Run on Kongregate if you’re so inclined. There are certainly worse ways to spend your next 97 seconds.

The Flixel community, while small, is growing by leaps and bounds, and is already more vibrant than other development communities I’ve been involved with. I made heavy use of Timothy Hely’s ludicrously detailed Flixel tutorial in creating both games, and had to poke around IRC for a bit to get some questions answered. The library itself is open source as well, so a little bit of hacking is all that ever stood between me and an (albeit) ugly solution to whatever problems I might encounter. A new version of Flixel is supposed to drop any day now, and I can’t wait!

One thing I would dearly love to see though: an official Flixel repository on Github or the like. There are enough people who’d love to contribute back to the library (myself included, I’d like to think) that this could turn into something huge rather quickly. Go Flixel! Go!

When working with massive NLP datasets, this is perhaps not an entirely good idea.

Lately my experiments have begun to take up more and more days to complete. Part of this, of course, is Ruby’s fault — the language, or at least the current interpreter, is far from fast — and part of the blame lies with me, for writing fundamentally lazy code. I have, however, come up with something of an interesting fix for the problem by parallelizing almost all of my big experiments. Easily done, really — but I then realized that I don’t have access to any of the department’s clusters. But I do have a login that works on all of the public-access machines in the (huge) undergraduate labs.

Bingo.

Enter clusterfuck, a subversive job-distribution tool I’ve been working on to solve this niggly little dilemma. It’s basically a tool for automating the process of ssh-ing into multiple machines and starting jobs on each of them, writ large. It’s installable via GitHub (I’ll push a gem out to Gemcutter when I have a nice, polished version ready) and configured rake-style via clusterfiles:

Clusterfuck::Task.new do |task|
    task.hosts = %w{clark asimov}
    task.jobs = ["hostname","hostname","hostname","hostname"]
    task.temp = "fragments"
    task.username = "SSHUSERNAME"
    task.password = "SSHPASSWORD"
    #task.debug = true
end

You kick off a batch of cluster jobs via the command clusterfuck (which takes a clusterfile as an argument, or defaults to clusterfile if it exists). This example file will run the command hostname four times on two machines (two each, unless one goes down or is slow to respond) and save the output of each command into a directory fragments. A bit of a toy example to be sure, but replacing the uninteresting hostname job with something more time-consuming and extend the list of hosts to, say, several dozen idle machines can get large, decomposable jobs completed in a fraction of the time necessary to run ‘em on a single machine.

Why “clusterfuck”? The early versions of this tool were, to say the least, somewhat unreliable, and had a frustrating tendency to leave cpu-intensive processes floating around. Needless to say, the network admins were not happy about this state of affairs, and the entire thing turned into a giant, well, you get the idea.

Install Flex SDK:

• Download the Flex SDK from http://www.adobe.com/cfusion/entitlement/index.cfm?e=flex3sdk
• Unzip the file we just downloaded (flex_sdk_3.4.zip) and copy the resulting folder (flex_sdk_3.4) somewhere out of mind. I stuck mine in ~/Library (/Library).
• Now we need to tell terminal where to find the Flex tools. Open up Terminal (Applications/Utilities/Terminal) and type open ~/.profile. This opens up your bash profile in TextEdit; add this line to the end of the file: export PATH=~/Library/flex_sdl_3.4/bin:PATH (if you put the flex_sdk_3.4 folder somewhere other than ~/Library, use that path here instead). Save the file and quit TextEdit
• Close and re-open Terminal (or type source ~/.profile, either works), and make sure everything works by typing mxmlc -help. You should get a screenful of text, starting with the line “Adobe Flex Compiler (mxmlc).” Success!

Flixel

• Download Flixel from http://flixel.org/flixel_v1.25.zip
• Unzip flixel_v1.25.zip
• In your Terminal window, change into the newly-created flixel folder. If you downloaded and unzipped Flixel to your Downloads folder, you can do this by typing cd ~/Downloads/flixel_v1.25/.
• Compile the Mode example with the Flex compiler by typing mxmlc Mode.as. You should see something like:

    Loading configuration file /Users/doches/Library/flex_sdk_3.4/frameworks/flex-config.xml
    /Users//Downloads/flixel_v1.25/Mode.swf (380608 bytes)

• Alright! If you look in the flixel_v1.25 folder you should now see Mode.swf — double click on this to open it up in the Flash Player (or type open Mode.swf in Terminal).

Ok — that’s everything we need to build Flash games using Flixel. I'd write a bit more about actually using the library, but that's definitely been taken care of by other, more talented, folks than I...

From the post:

Wikirunner is an a chase game inspired by Jeremy Bushnell’s Wikipedian Tag. Created for Mini Ludum Dare #12 (the theme was ‘Wikipedia’), two players are given a random Wikipedia page each, and then ‘the chaser’ must try to navigate his or her way to the same page as their opponent, while ‘the runner’ must try to stay off the same page as the chaser for as long as possible.

Both players can only move to another Wiki page if it has some relevance to the page they are currently on - so for example, you could move from ‘London Olympics’ to ‘2012’, but not from ‘Russia’ to ‘kangaroo’. The chaser also gets two goes for every one of the runner’s goes, to give him a fair chance. The game can be played in a 2-player hotseat style, or 1 vs AI, or AI vs AI (if you want to watch how the program thinks).

By far the most fun mode is an AI chaser vs a player runner. It’s interesting to see the choices the AI makes - at one point I changed to ‘Canada’, so the AI jumped over to a page on ‘Dumbledore’s Army’. Escaping to the Wiki page for ‘Iraq’, the program then tried to follow me by bringing up the page for ‘The Manchester Evening News’, which just so happens to be my local newspaper strangely enough.

Not this time, though.

I’ve got a pretty good set-up going: screenshots every two seconds under both windows and linux, autostarting on login for both (No forgetting!) and saving to an empty harddrive formatted to fat32 so both OSes can access it. Images are tagged with the time in a consistent format, too, so I can make sure they’re all in the right order after the dust settles and I get around to encoding the thing. In case you’re interested in repeating this feat for yourself, let me describe the software and hardware setup: One desktop, dual booting Linux and Vista + one Macbook, running OS X and equipped with built-in iSight camera. On Linux (Ubuntu, 64bit) I’m using scrot with a custom makefile, dumping JPEGs of my screen every 2 seconds. On Windows I’m using Keeyai’s excellent Chronolapse, a tool that I’m pretty sure came out of an earlier LD. I’m also using Chronolapse to merge everything together in the end, because it works with screenshots saved as a series of images and can do picture-in-picture compositing. For OS X I’m using EyeSight to take pictures with the iSight camera every 2 seconds. The laptop is sitting off to the side when I’m not using it, so that image will either show me working on the desktop, on the laptop, or not working at all (e.g. sleeping).

Not bad, eh? And all free software to boot.

This ought to be a good compo, and for a slew of reasons. The last compo, back in may, netted over a hundred submissions — breaking records we didn’t even know we were keeping. As for me, I’ve been all fired-up about this sort of indie development lately, partly thanks to mvromer’s influence, and partly due to attending the splendiferous Edinburgh Interactive Festival. Hopefully I’ll get enough work done during the week, meet all my goals and whatnot, that I can participate without inducing too much research-guilt. I guess we’ll see.

For example, you might rate 'Christianity/Religion' as a 7, because Christianity is a very typical religion, 'Humanism/Religion' as a 3, because Humanism is a somewhat unlikely religion, and 'Pastafarianism/Religion' as a 1, because Pastafarianism isn't like other religions at all.

Greetings from Amazon Mechanical Turk,

An Amazon Mechanical Turk user is contacting you from the Amazon
Mechanical Turk website.  Please review the message below and respond to
the message as you see fit.

Sincerely,
Amazon Mechanical Turk
http://requester.mturk.com
1200 12TH AVE South, SUITE 1200
SEATTLE, WA 98144-2734 USA
Message from Susan XXXXXX (XXXXXXXXXXXX@msn.com)
---------------------------------
Customer ID: A3VXXXXXXXXXXX
Hello,
 I cannot in good conscience work on your hits, although I am one of the higher educated 
monkeys around here with a high acceptance %.

 Who are you to decide Pastafarianism rates a 1 on the religion scale? That is bordering 
on blasphemy, and showing extreme bias against His Noodly Appendage. May he forgive 
you. Ramen.