I had two goals for Hack Day: (1) get a PS/2 keyboard talking to an Arduino and (2) make something interesting with processing.py. Here’s the end result (make sure to click through to the full-screen version for maximum legibility):

Crazy Animal Stories Keyboard from Adam Parrish on Vimeo.

It’s the Crazy Animal Stories Keyboard, a keyboard which intermittently replaces whatever you’re typing with a Crazy Animal Story.

It turns out that the part of this project that I thought would be difficult turned out to be easy: getting a PS/2 keyboard talking to an Arduino was a piece of cake. I already had a bunch of mini-din connectors; I just soldered one up to a breadboard, hooked it up to my trusty Arduino Diecimila, put the excellent ps2keypolled library in my libraries folder, plugged in the keyboard and voila: keystrokes gettin’ read.

Here's what the setup looks like

globbiest solders since middle school

I’ve got big plans for the PS/2-to-Arduino data chain, involving a data logging chip and shoes made of keyboards and sledgehammers and/or yogurt. But for Hack Day, I just wanted to whip up something fun. So the next step was to get the keystrokes from the Arduino to my computer, preferably into a processing.py sketch. Much to my surprise, Processing’s serial communication libraries worked with processing.py without a hitch*, which left me free to write the tiny little generative text toy that you see in the video above.

The biggest unforeseen timesink: I spent a few hours trying to figure out the best way to send ps2keypolled’s 16-bit key codes from the Arduino to the computer, eventually settling on the stupidest possible ad-hoc protocol that could work (and porting a big chunk of C code to Python to translate the key codes to ASCII). See the source code for more details.

Most surprising happy discovery: processing.py is amazing. Being able to quickly write the text-munging code in Python while still retaining Processing’s built-in functions and easy-to-use libraries is just… a revelation. For a project that’s just a few weeks old, it feels surprisingly polished. If you’ve got Python and Processing expertise, I recommend you give it a go.

Source code for the whole shebang: crazy_animal_keyboard_source.zip

Here’s a picture of Mr. Brendan Berg enjoying his time with the device, while I appear to be leering lecherously:

* Okay, there was a single hitch. Apparently, the serial communication library included with Processing (and, therefore, processing.py) doesn’t support 64-bit Snow Leopard (as documented e.g. here). I was able to get around this without problems by using the -d32 parameter to the java runner, i.e.

$ java -d32 -jar processing.py animal_keyboard.py


Text lathe prototype from Adam Parrish on Vimeo.

This is a little prototype for a textual interface that I came up with last week after receiving my nanoKONTROL. (I saw Jörg Piringer use one of these in a live electronic sound poetry performance last year at E-Poetry, and I knew I had to have one.) The idea is that two knobs on the controller determine how much text is cut from either side of a text fed to the program on standard input; another knob controls how fast lines of text are read in and displayed. It’s a very simple mapping, but I’m pleased with the results so far.

An experiment in interfaces for generative text from Jason Nelson (whom you may better know as the creator of i made this. you play this. we are enemies and game, game, game and again game).

The snippets of text are arranged in hierarchical menus, and seem to cohere both vertically (from top to bottom within the same level of hierarchy) and horizontally (from left to right, as you drill down deeper into the hierarchy). I would be interested to hear from Jason how the snippets were composed, and what his methodology was for arranging them.

I’m struck by the similarities between this piece and Nick Montfort’s ppg256 series. While Montfort and Nelson clearly have different stylistic aims, both are using computers to define procedures for combining snippets of text. The procedure in A Tree With Managers… relies more heavily on interactivity than the procedure in ppg256, but the underlying data structures, and the kinds of choices that can be made, are analogous.

(One method of more directly comparing the output of the two procedures might be to transcribe the snippets in A Tree With Managers…, along with their relationships, then create a program to randomly traverse them. Maybe a weekend project?)

(via, where you can also find comments and discussion)

The procedure: scrape Twitter’s public timeline and find rhyming couplets. The effect is striking: even though the juxtaposition of tweets is essentially random, the presence of rhyme gives them a strange cohesion.

The only obvious weirdness comes when the procedure tries to rhyme emoticons, as in the following couplet:

Finished a paper for class and time to relax. Yay me!!
Showered and feeling good :) How are y’all smelling? :b

On second thought, I like that: it’s as though the procedure suggests you read the emoticon aloud in a cutesy way (“time to relax, yay me! / … how are y’all smelling? colon lowercase bee”).

(via)

Murmur Study from Christopher Baker on Vimeo.

Murmur Study is a physicalized reading of Twitter, created by artists Christopher Baker and Márton András Juhász. (More details and photos.) The process, according to the artist’s site:

This installation consists of 30 thermal printers that continuously monitor Twitter for new messages containing variations on common emotional utterances. Messages containing hundreds of variations on words such as argh, meh, grrrr, oooo, ewww, and hmph, are printed as an endless waterfall of text accumulating in tangled piles below.

I’m not quite sure I understand the reason to single out tweets that match those particular text patterns—how is this format more appropriate for illustrating the mass of “emotional” tweets? (as opposed to tweets about kittens, tweet spam, tweets from political figures, tweets about thermal printers, etc.) Stunning in its scale, nevertheless.

See also: bitfall and Simanowski’s keynote from e-poetry 2009 (not linked, because I can’t find a link).

(via rhizome.org)