Casey Reas and Chandler McWilliams asked visual designers why they write their own software and how it affects their process:

The answers reflect the individuality of the designers and their process, but some ideas are persistent. The most consistent answer is that custom software is written because it gives more control. This control is often expressed as individual freedom. Another thread is writing custom software to create a precise realization for a precise idea. To put it another way, writing custom code is one way to move away from generic solutions; new tools can create new opportunities.

Most of the interviewees are media artists, but there are a couple of names you'll recognize. My favorite, Amanda Cox, uses a Mad Libs metaphor:

Mad Libs is a game where key words in a short story have been replaced with blanks. Players fill in the blanks with designated parts of speech (“noun”, “adverb”) or types of words (“body part”, “type of liquid”), without seeing the rest of the story. Occasionally, hilarity ensues, but no one really believes that this is an effective method for generating great literature.

I'm looking at you, non-programming statistician.

Update: The article isn't there anymore, so you can read the cached page for now.

We've seen sorting algorithms visualized and auralized, but now it's time to see them through the spirit of Hungarian folk dance. In a series of four videos (so far), folks at Sapientia University in Romania demonstrate how different sorting algorithms work with numbered people dancing around and arranging themselves from least to greatest.

See them in action in the video below. This one is for Bubble-sort. They move with such zest.

[Video Link via @shancarter & Boing Boing]

You know those compressed movie barcodes that we saw last week? Here's a Python script by Benoît Romito to make your own. Run a .avi format movie through, and voila. Free gift idea: digitize some old home movies and make a personalized barcode for your family.

It's not just about saving time. There are certain things you can discover and be creative with with computation that you can't by hand. They both go together.

Watch the four-minute interview below. The excitement in Shiffman's voice alone might want to make you learn some Processing (which he wrote a useful book for).

[Mark Webster via @ben_fry]

The Gist of It

Creating my own Twitter bot was pretty straightforward (much more than I thought it'd be), mostly because Twitter provides an API and the resources to make it that way.

I wanted something really simple that I could play around with. I just wanted to be able to send a direct message to my Twitter bot, and from there, it would store my data. OK, so here are the basic steps I took:

1. Create Twitter account for bot
2. Turn on email notification for direct messages only
3. Check email periodically for new direct messages
4. Parse direct messages and store in database

Create a Twitter Account (and Email Address)

The first step is easy. Create a Twitter account specifically for your bot. The account name should be short and easy to remember. Make sure you enter an IMAP email address that is only for your bot. You could put in a general purpose email address, but it'll make your life a lot easier if the email address was specifically for Twitter.

Turn on Email Notifications

Once you've setup your bot account, turn on email notification via the Twitter options menu. For now, tell Twitter to only send you notifications when your bot receives direct messages and not when someone new follows.

Check Email and Do Something with Messages

Here's where the actual code comes in. Here's the general framework. I've left out some details that will be specific to your own purposes.

 
from imaplib import *
from email.Parser import Parser
import datetime, time, email, email.Utils
import re
 
# Connect to email server
server = IMAP4("__EMAIL_SERVER.COM__")
server.login("__EMAIL_ACCOUNT_NAME__", "__EMAIL_PASSWORD__")
r = server.select("INBOX")
 
# Find only new mail (i.e. new direct messages)
r, data = server.search(None, "(NEW)")
 
# If there are new direct messages:
if len(data[0]) > 0:
 
    p = Parser()
 
    # Loop through new emails
    for num in data[0].split():
 
        # Who email is from (Should be one line, broken for display only)
        r, data = server.fetch(num, '(BODY[HEADER.FIELDS
            (DATE SUBJECT FROM X-TwitterEmailType X-TwitterSenderScreenName
            X-TwitterCreatedAt X-TwitterRecipientScreenName)])')
        msg = p.parsestr(data[0][1])
        who = msg.__getitem__('From')
        matchemail = re.compile(r'[\w\-][\w\-\.]+@[\w\-][\w\-\.]+[a-zA-Z]{1,4}')
        email_addy = matchemail.findall(who)[0]
 
        # Twitter username
        twitter_un = msg.__getitem__('X-TwitterSenderScreenName')
 
        # If the email is a direct message sent from Twitter
        if msg.__getitem__('X-TwitterEmailType') == 'direct_message':
 
	    # When direct message sent, convert to epoch seconds
            twitter_time = msg.__getitem__('X-TwitterCreatedAt').strip()
            time_tuple = email.Utils.parsedate(twitter_time)
            epoch_seconds = time.mktime(time_tuple)
 
            # Get body of email sent by Twitter
            r, data = server.fetch(num, '(RFC822.TEXT)')
            body = data[0][1]
            twitter_dm = body.split("\r\n\r\n")[0].strip()
 
            # Do something with the twitter direct message...
            # Parse it...
            # Store it in a database?...
 
# Logout of email server
server.logout()
 

I run this script every 30 minutes with a cron. You could of course run it more frequently. The important part of this code though is that Twitter attaches its own special headers (e.g. X-TwitterEmailType). If you wanted your bot to automatically follow users that followed it, you could check the EmailType and then use the Twitter API to follow a Twitter user. For my simple purposes though, I only cared about direct messages.

That's all. There is of course plenty of room for improvement. Like I said, you could make this useful to lots of users by making your bot automatically follow those who follow it. Users can only direct message another Twitter user, if he is following. I would also delete emails that have already been read and stored somewhere so that the INBOX doesn't pile up. Yup.

Did I miss anything?