A logo of my personal brand

Code Words at the School for Poetic Computation

A few weeks ago, I applied for and was accepted into a week-long session at the School for Poetic Computation called Code Words. The goal of the class intrigued me; it was a week-long session designed to “explore how computation relates to language and art, focusing on literary art and poetry.”

I wanted to continue to explore newer ways of programmatic expression, and I loved the premise, but I wasn’t entirely sure what I was getting myself into. I expected a mix of lectures and readings to get you to think about the relationship between words and programming, with time set aside during the course to program on projects together as a class.

The structure of the class was not at all what I expected, and I had an absolutely delightful experience. I looked forward to finding out what each class would bring. Each day was divided into three chunks of hour-long segments, with a guest lecturer that wrote prose, poetry, or code. For the first hour, our teacher would introduce themselves and their work. The next hour was devoted to demos from students on something they had created since the last class. And in the final hour, the guest lecturer would return to provide the students with a prompt for what their next demo should be.

The absolute hardest portion of the course was finding time to create a demo based on the given prompt. With a full-time job taking up most of my day, I had something like one to three hours to cobble together a project. Although at first I struggled against the rapid pace, I realized that this ended up being extremely beneficial for me. I often spend way too much time on the small details of a project. Being able to just think of an idea and throw something together, confined by time and my other responsibilities, helped me create something new and worry about the perfecting details later.

One was expected to have some programming knowledge; a few of the classes were centered around Python. Text processing libraries not withstanding, I dislike Python for a number of reasons, but the two biggest ones are that

  • years after Python 3’s announcement, many packages (and tutorials!) are still catered to Python 2, which is an incompatible release; and

  • Python claims that “beautiful is better than ugly” and “explicit is better than implicit,” but is utterly hypocritical in practice.

    For example, I spent a few minutes trying to figure out how to branch an if statement:

      if x == 3:
        # do something
      else if x == 4:
        # do something else

    It’s not else if, but rather, elif. How elif is more explicit than else if, I have no idea.

Thankfully it turned out that using Python wasn’t a major requirement for creating demos, so for most of the projects, I switched to using JavaScript instead. This also had the advantage of letting me toss the works onto my domain under GitHub Pages for easier sharing.

I wanted to write a bit on what the classes entailed (and share the projects I was able to come up with).


Sunday’s class was taught by Nick Montfort, who also facilitated the Code Words course throughout the week.

The theme of the class was getting comfortable with the idea of repetition. We looked at modern implementations of randomly generated texts from the 50s and 60s, as well as new techniques for generating sentences. Even though the words themselves were plucked at random, the texts could still evoke an emotion from its human readers. Initially, the focus was on understanding why these programs affected us. Most followed a recognizable pattern; but the words themselves were deliberately selected to have a designated impact. It was the first time I’d heard this sort of mot juste talk outside of literature.

Our assignment for this class was to not only create a program that generated text and turn it into a zine. I came up with Constraint Zine. My thinking was that if I could not control the order in which the words appeared, I ought to introduce some dynamism by picking words that could be used in various grammatical arrangements. For example, the text spit out a basic <LOCATION> <STATE> <VERB> arrangement, but I made sure that the “state” and the “verb” tenses could change, and still match:



Monday’s class was led by Stephanie Strickland.

The theme of this day was to examine the ways in which content is perceived. We took a look at The Ballad of Sand and Harry Soot, which is a sort of choose-your-own-hypertext adventure for navigating some text. Stephanie also showed us a short story written as Powerpoint slides, which was a clever (and devious) way to offer a narrative, since slideshows are universally abhorred, and one’s natural instinct is to tense up whenever someone says “Come, sit down, I have a presentation I want you to see.”

The assignment for this class was to present text in a way that wasn’t deliberately straightforward. I came up with Space, an intentionally enormous website that asked a viewer to scroll around in their browser to “collect” all of the words in a short piece about space.


Tuesday’s class was taught by Milton Läufer, and its theme was around constraints–either technical (programs less than 256KB, for instance) or imposed in a Oulipian fashion.

We took a look at Flash Fiction, which takes several words and rearranges them endlessly to try and create a narrative using the least amount of words necessary. In a similar vein, we looked at Scenes from a Marriage. I really liked the examples from this day. It always tickles me when people can fit an enormous amount of creativity in a limited amount of space.

The assignment for this class was to create something with a sense of restriction. To that end, I built Shimmer, which, admittedly, was probably the hastiest project I came up with. It takes the well-known Borges stores Funes the Memorious and constantly reshuffles the letters so that vowels appear and disappear at random.


Wednesday’s class was taught by Lillian Yvonne-Bertram.

Lillian spoke at length about what it meant to use an algorithm to produce text. She read through her poem, @Tubman’s_Rock, which was a combination of texts from Gwendolyn Brooks and a CNN article about placing Harriet Tubman on the American twenty dollar bill. Every action (and inaction) is a political statement, and Lillian explained that the algorithms we build and the texts constructed by programs all have a human intent behind them. To remix someone else’s texts is to imbue love unto existing works. A poem written by a computer may not “really” be a poem, but all creations are forged through choice, and a computer-generated poem simply foregrounds the choices of words inevitably selected by a human.

Our assignment was to take one of her existing mash-up algorithms and create something new. I chose to mix together academic criticism of e.e. cummings with his actual poems. I thought some of the combinations of his terseness with the overly pompous texts were quite funny:

since feeling is first
cummings' poetry often deals with themes of love and nature, as well as the relationship of the individual to the masses and to the world.
and break onetwothreefourfive pigeonsjustlikethat


On Thursday, Everest Pipkin came and spoke about a concept near and dear to my heart: data liberation and website scraping. They showed some of their projects, my favorite of which was cloud translation, which, given a location on a map, showed you what the clouds looked like from the Google car that mapped out that terrain. We talked about how to take content from websites that didn’t necessarily have an API, which is fundamentally an important skill to have.

The assignment, then, was to create a program that scraped text from a website. I actually didn’t build anything for this class! Having already written software that parses HTML, I couldn’t think of any new direction to take.


On Friday, every student was to come up with one final project to show to the class and some of the teachers what they had learned.

For a few months, I’d had an idea to present some text in such a way that basically forced the reader to sit still and read it. For the final assignment, I wrote focus_concentrate, which uses a webcam to detect your face and only cycles through text if you’re looking directly at the camera. A series of distractions will appear to try to throw you off. I intend to take this idea and create an even more masochistic version in the future!