Digital poetry in Silicon Valley

40 minutes of Exquisite Haiku, squeezed down to 90 seconds, set to Mendelssohn.

For about two years, back between 2011 and 2013, I spent a bunch of time working on a very strange, very fun project called Exquisite Haiku. The name (originally coined by Bethany Nowviskie) was a play on the Exquisite Corpse, a classic surrealist parlor game from 1920s Paris that involved a bunch of people sitting around a table, passing around a piece of paper, and writing a poem together. I was curious to see if I could make a digital version of the same idea – a piece of software that would make it possible for groups of people to work together to compose short little poems that would emerge, in some kind of organic way, from the collective intelligence of the group.

An early version of this idea popped into my head back in college, when I was reading a bunch of literary theory and got interested in the idea of an “authorless” text, which, for various reasons, was a kind of recurring thought experiment that runs through a big chunk of 20th century literary criticism. In the 40s and 50s, the New Critics argued that the meaning of a piece of literature should be broken away from the intention of the person who wrote it – all texts should be treated as if they don’t have authors. Soon after, in the political climate of the 60s, the author became associated with authority – a constraint on how you could read a piece of literature. Barthes declared that the author was “dead,” and Foucault followed up that the author was just a “system.” In the 70s and 80s, the post-structuralists agreed, but asked whether it was ever necessary to “kill” the author in the first place – the author was always just a mirage, they said, an illusion of a unified source of meaning that never actually existed. All texts are “authorless,” in a way, and always have been.

Not everyone agreed, though. In the early 80s, Steven Knapp and Walter Michaels basically called everyone’s bluff and argued that a text just means whatever the author thinks it means. In a famous essay called “Against Theory,” they try to imagine a text that actually has no author – a poem that gets scratched into the sand on a beach by the random movement of the waves and sea drift. If nobody wrote it, is it actually a poem? Does it mean anything? Knapp and Michaels say “no,” most modern literary critics would say “yes.” Probably, both sides are right, and it’s just a question of how you define “poem” and “meaning.” Either way, though, I was fascinated by the thought experiment of a text that comes from nowhere. For Knapp and Michaels, it’s basically meant to be an absurdity – something so unrealistic that it casts into relief the extent to which we just do, when push comes to shove, trace the meaning of a text back to its author. But, I wondered – what if you turned the thought experiment into a real experiment? Could you actually create one of Knapp and Michaels’ “wave poems”? A text that literally doesn’t have an author, but still has all the qualities of a text that does – the unity, the coherence, the sense that it actually means something? What would a text like that look? What would you learn along the way? How would you even start?

This is a fun paradox. You can’t just sit down and write one yourself, since then you’d be the author. And, short of inventing some kind of magical AI, it’s hard to write a computer program to generate a poem that fits the bill. It’s easy to spit out random texts, or to cobble together little bits of existing texts in new ways, but that throws the baby out with the bath water – the author is gone, but so is any sense that the text is a fully-qualified speech act. Then, I started thinking about a third way. What if, instead of trying to remove the author – going from 1 author to 0 authors – you actually load up the poem with lots of authors – 2, 20, 200, 2000, ∞ – with the goal of spreading the authorship so thin that it effectively disappears? Distribute it across lots of people until it becomes so scrambled, so finely-chopped, that it becomes impossible to attribute anything in the poem to an individual person. You’d need an extreme form of collaboration, a little social contract that could roll together the ideas of lots of people in a perfectly balanced way that would represent all of them at once, but none of them individually.

Crowd sourcing vs. crowd production

Anyway, by the time I started building out a prototype in 2011, I was bored with the literary theory but fascinated by this second version of the question. Which, the more I thought about it, seemed to open up into a bigger set of questions about the strengths and weaknesses of digital collaboration – what it can do, what it can’t, and whether it’s possible to think up crazy computer programs that could fundamentally alter the balance. At the time, lots of cool ideas were floating around about how internet-enabled cooperation could be used to chip away at problems in journalism, scholarship, and cultural heritage. At UCL, Transcribe Bentham was using crowdsourcing to transcribe the manuscripts of Jeremy Bentham; CHNM was working on Scripto, a general-purpose framework for community transcription; and, at the Scholars’ Lab, we were working on Prism, a tool for collaborative text annotation (before the name was a synonym for evil!). Outside the university, Rap Genius was just getting started, and was building a distributed annotation layer for the web. And, of course, 800-pound gorillas like Wikipedia and OpenStreetMap have been around for over a decade.

I realized, though, that I needed something a bit different. Instead of crowd sourcing – doling out self-contained little tasks to individual people in isolation – I was curious if you could engineer a form of crowd production, a social algorithm that could bind people together in a very specific way that would allow them to collectively produce a single, unified object. If Wikipedia and OpenStreetMap are like massive lego sets that can be built up one little brick at a time, a poem is like a glass vase – it’s a single piece of material, and there’s no obvious way to cobble it together from different sources. How do you funnel the energies of a group of people into a single poem with a single point of view? After tinkering around for about a year, here’s what I came up with:


Everyone works together over the course of 20-30 minutes to write a three-line haiku. Each word in the poem is picked individually through a process of interactive voting that plays out over the course of 2-3 minutes (all the variables can be configured at the start of the game). When the clock runs out, the word with the most points is locked into place and the process starts over for the next word, with the whole cycle repeating until the poem matches the standard 5-7-5 syllable pattern.


At the start of each “word round,” everyone types proposals into the blank at the top of the screen, and the words get pushed onto the main “ranking stack” below the poem:


As soon as some words get added, the players can start to influence the order of the stack by spending out little bursts of positive or negative points onto individual words. Under the hood, each vote is converted into a decay function that gradually adds or subtracts points from the word over the course of 30-40 seconds. Every couple hundred milliseconds, the server rounds up all the votes and computes an updated ranking for all of the words using a procedure very similar to the algorithms used to rank submission on link aggregators like Hackers News or Reddit. Then, the new data slice gets pushed into the client using, and the front-end application continuously syncs the screen to show the current game state:


As soon as a vote is cast, it’s also added to the “log stack” on the left side of the screen, which displays a running list of all votes as soon as they’re submitted. If the ranking stack gives a sense of the cumulative effect of all the votes that have been cast since the beginning of the round, the log stack is like a stock ticker, a pulse of what’s happening at any given moment. Votes in the log stack can also be “revoted” (sort of like retweeting) by clicking on them, which has the effect of re-submitting a identical vote on that word with the same quantity and direction (up or down). This makes the game more volatile – if the group latches onto a vote and revotes it lots of times, a word can be pushed up or down in the stack very quickly, even at the very end of a round:


Once you get a couple of people hammering on the interface, it turns into a shifting, churning, blinking tableau of words – a visual representation of the aggregate sentiment of the entire group at any given moment. The idea was to try to build an interface that would make it possible to have a kind of visual conversation about where to take the poem. Words are floated to the top and floated back down, tried out and then abandoned in favor of other ideas. A new submission or a large vote can trigger a flurry of agreement or dissent. Competing factions form around words, and people will often pace their points strategically to protect or bolster the position of a word in the stack. The whole thing quickly turns into an exercise in applied political philosophy – the game becomes an tiny legal or legal or economic system, a legislative process for picking words that tries to distill a single course of action from lots of little vectors of artistic intention.

Software archaeology

Anyway, I had an absolute ball working on this. But, just as I was finishing up the code and starting to play the game with friends in Charlottesville, I got swept up in other cool things happening at work, and other interesting side projects started jostling for attention on nights and weekends. I actually gave a paper about the project at the DH conference in Nebraska last year, but by that point I hadn’t done much with the code in about six months. And, after moving out to California and gearing up on other projects, it slowly slipped out of sight and out of mind.

Which gnawed at me, because I had never found time to actually use it in the way I had imagined – as a way to bind people together around poetry, a way to create a sense of community around words, language, literature, and art, if only for 30 or 40 minutes. So, I decided to set off on a little project of software archaeology – I would pull the codebase down off the shelf, get it back up and running, put a new coat of paint on it, and then spend a few weeks writing poems with friends around the Bay Area. First up was Peter Shaw, a new media artist and generally fascinating guy I met at Philz Coffee in Palo Alto. We ended up with an interesting little meditation about living in the present:

face the bliss despite
crazy blueness few see the
lovely timeliness

Then, Kara and I wrote a couple of poems. Our first attempt was a little muddled. But, towards the end, it closed in (I think) towards an interesting question about whether we’re able to identify with animals that occupy a “small[er] world,” an order-of-magnitude difference in size or cognition – in this case, the “little fly” of the first sentence:

see the little fly
does my love contain bits of
another small world

The next one was about seasons. Apparently, we miss the east coast:

western winters do
little to move me we came
from an older cold

I like the shift from “me” to “we” at words 7 and 8, which is interesting in the context of the format. Next came a poem about programming, something we’ve both been doing a lot of recently:

bits fly by fingers
slap against squiggles eyes fill
up with a fever

Playing with two is fun, but I was curious to see what would happen with a bigger group. So, a couple of weeks ago, we decided to invite a bunch of people over, eat some food, and write some poems. It was sort of like an old-school, late-90s LAN party:


We ended up with this little poem, which is either very depressing or very hilarious:

never forget me
when I drift freely towards

Anyway – code is here, one-dyno Heroku instance is here. Happy poems!