I ♥ E-Poetry

This generative poem produces an expert mashup of Emily Dickinson’s poetry and Herman Melville’s Moby Dick, described in detail by the authors in the introduction to their piece.

Sea and Spar Between is a poetry generator which defines a space of language populated by a number of stanzas comparable to the number of fish in the sea, around 225 trillion. Each stanza is indicated by two coordinates, as with latitude and longitude. They range from 0 : 0 to 14992383 : 14992383.

In the tradition of massive generative poems initiated by Raymond Queneau’s Cent Mille Milliards de Poémes, this is an impossible text to read completely in a lifetime, requiring 6,421,232,876.71 years of reading, 24 hours a day, 7 days a week, 365 days a year (with a day of rest on leap years)— if you allot 30 seconds to read each stanza. Fortunately just as one doesn’t need to navigate the seven seas to appreciate them, this poem doesn’t need to be apprehended in its entirety to be enjoyed. And Montfort and Strickland have provided us with an interface that invites exploration in both serendipitous and precise ways.

A distinctive feature of this poem is that while it is generative, it isn’t random or mutable. Every possible permutation is expressed spatially on the canvas and numbered with X,Y coordinates, which means you can reread it, make note of coordinates to share passages, and enter coordinates to explore it strategically. By placing readers on a randomly determined stanza, we are encouraged to discover new parts of this poetic inquiry. The screen captured image above is taken from one such random assignment

In an attempt to chart some of these poetic waters, I entered the starting (0:0) and ending (14992383 : 14992383) coordinates to see the range of permutations (see below).

Read stanza 0:0 in the center and the surrounding stanzas to notice similarities and you’ll sense a pattern in how the structure arranges the exploration of each permutation in the variables. Montfort and Strickland have wisely chosen to not make it too similar or obvious to avoid monotony, but there is a spatial and mathematical logic to the arrangement, which can be discovered in the source code by those interested in understanding that particular mechanism.

An interesting detail about its structure that is illuminated by the code can be discovered by reading the stanza positioned on the top left corner of the screenshot, diagonal from stanza 0:0. Read it in the image above and then examine the image below, screen-captured from the last coordinate in the set.

The stanza on the lower right corner is the first one (0:0), which means that this is not a flat mapping with edges, but a circular one with the end looping back to the beginning. The source code documentation explains that the structure is that of a torus, and I imagine it is formed around the diagonal circle defined by the sequence that goes from 0:0, 1:1, 2:2, all the way to 14992383 : 14992383. By that logic, the farthest point from both the beginning is the middle point, 7496191.5 : 7496191.5 (rounded up to the next integer), depicted below.

How thematically or stylistically distant is this midpoint from the beginning and end? Not very, but one can immediately notice some of the recurring patterns, variations, and variables around the phrase “artless is the earth,” each of which builds a different kind of statement. Reading around these axial stanzas may reveal stronger insights on how the poem’s data set informs the poem as a whole, as may dividing the poem into a grid and mapping out its structure in regions. Reading the source code would also reveal much of its internal logic, but reading the code alone doesn’t do justice to the emergent complexity of the piece.

I suggest taking a variety of approaches to reading this work in addition to the ones described above, including reloading the page to go to a different random location, and using your mouse pointer to explore intriguing directions in the stanzas. And accept that you will never know all of this poetic sea, though you may map out some of its currents, coastlines, and psychogeography.

Spoiler alert: Are you experienced?

• If you have never read “Taroko Gorge,” read this first. (You’re in for a treat!)
• If you haven’t read any of its remixes, read some entries (and poems).
• If you’re experienced in this set of poems, read on.

On January 8, 2009, Nick Montfort published “Taroko Gorge” a generative e-poem written and programmed in Python and ported to JavaScript for Web publication. When opened, the code generates a nature poem about the famous Taroko Gorge national park in Taiwan. Part of its interest is that it produces endless permutations of its elements— stones, coves, forests, crags, basins, flows, mists, and the occasional monkey sightings— recreating part of the experience of hiking down this river canyon. Its scheduled, endlessly generated nature parallels the endless flux and change of nature over time. Just as you can never step into the same river twice, you cannot reread the same text of the poem. But rivers and the canyons they carve can be named, can produce consistent experiences for those who explore them in the same way that the output of the “Taroko Gorge” script produces a consistent poetic experience. With this poem, Montfort recreates an endless pattern of change found in nature.

This core idea and the code that generates it has proven to be very versatile, since over the past 3 years many people have produced remixes of the poem that redirect this idea towards other endless permutations in human existence. Some of the topics explored by the remixes are: sexuality, dating, toys, urban environments, cooking, eating, fandom, labyrinths, poetry, cultural movements, music, and the poem itself. Their tone has been equally varied: playful, shocking, serious, humorous, and earnest at times. Two conventions have developed in these remixes: a title that somehow echoes the original (generally through alliteration, repetition, or rhyme), and crediting Nick Montfort (and other remixers) by providing a link to the original, but using the <del> tag to strike out his name, inserting their own name in the authorial position.

This edition of “Taroko Gorge” is the only remix published by Nick Montfort, and it generates text from exactly the same code, but it is a significantly different variation from the original. In a panel presentation of “Taroko Gorge” variants at the ELO 2012 conference, Montfort read this statement, excerpted below:

In addition to including a date, the new version of “Taroko Gorge” includes the names of all known vandals, those who have replaced my own lyrical words and phrases with ones associated with various other individual visions, ranging from the idiosyncratic to the downright perverse. These appear on the right-hand side – stricken out. Since it is not proper to condemn people without evidence – unless we put them aboard a plane and take them to another country – I have also included links to the offending Web pages.

This remix of “Taroko Gorge” asserts something very simple: that the rebirth of the author comes at the expense of the death of other authors. Something simple, about originality, voice, and purity of essence, which has been said in so many ways: Remix = death. Take back the gorge. Don’t tread on me. There’s a bear in the woods. Make it old. I did it my way. Under the page, the code.

These three poems by Nick Montfort take an ancient literary and cultural tradition, the riddle, and brings them into the digital age by using CGI scripting to allow readers to guess the response without the riddler needing to be present. The poems provide a simple input cue: a text box where the reader can type in their guess and a button that submits that response to a script, which checks the answer for a match and sends a response, whether it was correct or not. This script was probably written in Perl, a programming language Montfort uses extensively, particularly in his “ppg256” series of poem generators. Part of the interest in this choice of scripting language is that he is able to keep the answer hidden from readers, even from those who like to take a peek at the source code (like me). It also means that he could design a riddle without a correct answer, enacting what Philippe Bootz calls “the Aesthetics of Frustration.”

But what is the point of a riddle? Is the pleasure in the answer in puzzling over the question?

This literary game which can be equally used to create prose and verse is a tribute to the Surrealist parlor game known as the “exquisite cadaver” and the paper-based Mad Libs created by Roger Price and Leonard Stern in 1953 (for more details, read Montfort’s introduction to the Literary Games issue of Poems that GO). This program originally created in Perl allows people to create texts and tag words to become “dreamfields.” When someone blindly fills in the dreamfield, it reconstructs the text with the reader’s input. Hilarity ensues.

This work is currently not functioning online. The Internet Archive has “crawled” this work 62 times since 2003, which means that one can access earlier copies of this work along with different dreamfields ready for you to fill in. This is an imperfect preservation of the work, however, because you cannot read the works produced. At least you can get an idea of what were some of the works created with this framework.

And if you’d like a taste of how this works, try out “Newspaper Ads” by Price and Stern: the very first Mad Lib in their first of many books.

This one-line code poem for the Commodore 64 produces the output you see in the screen capture above, though this short video documentation will show it in action. When executed, it randomly generates one of two characters that look like, / or \  (the actual codes are pure diagonal lines used as drawing elements), repeating the operation forever unless interrupted. This poem will is the subject of an MIT Press book which will feature 10 academics writing about this code work from different perspectives.

The emergent complexity from this deceptively simple work is part of its interest. The results you see in the image and video are from emulated version, which seek to replicate the computational conditions in which this version of BASIC ran, the Commodore 64. This popular computer system from the 1980s had a video output of it of 40 columns of text, using the PETSCII character set, which meant that the code poem would produce 40 / or \ before needing to go to the next line. The monospaced font meant that the characters would line up perfectly to produce the results you see.

But what do you see when you look at this output? I see a labyrinth, which I try to navigate with my gaze. I see letters, such as the E, F, P, a square-top A, O (or is it 0?). I see great complexity emerge from such a simple line of code, the kind that is incomplete without a human being to read into it. We can look at this maze as a visual art object, but let’s not forget we’re also reading characters: unvoiced parts of our alphabet, this building block of written language.

I see a poem.

Note: updated on November 27, 2012.

When I read “Taroko Gorge,” by Nick Montfort, something about the endless scrolling through a natural landscape made me think of Gary Snyder’s masterpiece Mountains and Rivers without End, inspired largely by Chinese landscape scroll paintings.

As a longtime reader and admirer of Snyder’s poetry this mashup arises out of deep respect for both Snyder’s and Montfort’s work. This is not intended to imitate or generate lines by Snyder: merely to gestures towards his poetry. “Taroko Gary” is a path through a digital landscape, built out of Nick’s trailblazing poetry generation code and using some of Snyder’s words from “Endless Streams and Mountains” as cobbles.

So I have to thank Gary Snyder for his amazing poetry, Nick Montfort for “Taroko Gorge” and for inviting me to actualize the affinity I felt between his poem and Snyder’s work, and Mark Marino for starting this discussion thread in the Critical Code Studies Working Group 2012.

This piece is a minimalist language and poetry generator that assembles words and organizes them into lines of poetry of varying length from two bigram datasets, and assigns them a generated title, beginning with the word “the.” The image above is a sample of its results: mostly recognizable words, creating phrases that may or may not have semantic coherence, forming lines that could be metrically described as amphimacic monometer (/ _ /).

More importantly, by shaping the output of this program to fit poetic conventions and offering its result as poetry, it promotes reflection on the nature of poetry, its social function, and our own willingness to accept the results of a program as poetry.

• To what extent are we willing to play along with the word juxtapositions that seem to make no sense, if we know that they are the product of random processes and not a human mind that intended to communicate something?
• Then again, can the poems generated by “ppg256” be attributed to Nick Montfort, who obviously made carefully considered choices in programming this piece?
• What about readers who encounter one of these poems without knowing the context or its author(s), will they become unknowing participants in a Turing Test?

These are timely questions worth thinking about, as Mark Marino has in a detailed Critical Code reading “The ppg256 Perl Primer: The Poetry of Techneculture.”

The lines of this poem cascade down the screen, describing a peaceful natural scene. Its pacing is meditative, reminiscent of some Gary Snyder poems. Its rhythm is mostly iambic with abundant trochees at the beginning of lines and occasional spondees to punctuate moments in the poem. The pacing of the scrolling lines doesn’t let you stop and look away, but won’t be too demanding, and once a line scrolls past visibility it is gone: you cannot scroll up or down. Live the moment in this poem for as long as it lasts, until you reach the end or realize what’s going on… whichever comes first.

The JavaScript engine for this poem inspired a number of variations on this poem by prominent writers in the e-lit and digital humanities community, available here.

Note (May 10, 2012): This poem has been the subject of over 20 documented remixes, using its code to produce a great variety of poems. I have already written about several remixes and from December 12-29, 2012 I will write about the rest, concluding the sequence by revisiting the original poem. You can access my postings by clicking on the Taroko Gorge tag below.

Upon completing my reading of the poetry in the Electronic Literature Collection, Volume 1 (tagged as ELC1 in this blog), some numbers and reflection on the works within is in order.

The ELC1 contains 60 works of e-literature, 38 of which are classifiable as poetry. Some of these works are certainly on the margins of what one might consider poetry, but I chose to include rather than exclude when in doubt. The authoring software distribution for these works is as follows:

The dominance of Flash as an authoring software and mode of publication is clear during the time this Collection was published (2006), perhaps for its smooth integration of multiple media, smooth animation, precise scheduling capability, and its ability to imbue a work with responsiveness. Mutability is not its strong suit, except when linked to user interaction. The poets who sought to create strongly combinatorial or generative works went with scripting languages such as Java, JavaScript, DHTML, and Processing, perhaps because they allowed more granular control over the programming codes.

The textual behaviors exhibited by the works in the collections are distributed as follows:

Of the 38 works, the most used behavior was scheduling (25), indicating an interest in exploring the possibilities of writing in a time-based medium. This was followed closely by responsiveness (24), which suggests that the other fascination lay in including the readers in the performance of the work in ways that the work could respond to. Static and kinetic texts were equally represented with 20 poems apiece, which might mean that they hold an equal interest for poets. The relatively low number of mutable poems (15) may be linked to the prevalence of Flash as authoring software, but not the 17 aural works, which is easy to handle with that program. Still almost half of the works (45%) incorporated some sort of sound, which points at some interest.

These numbers are from a relatively small sample, and one chosen by an editorial team that perhaps sought to represent a variety of practices in e-literature , so we cannot attribute too much importance. But they do point towards a trend in the development of e-literature, one that may change or become more defined over time.

This Collection was very well reviewed and received by the academic community, and with good reason, since the editorial board is composed of recognized poets and scholars in the field: Katherine Hayles, Nick Montfort, Scott Rettberg, and Stephanie Strickland. For a thorough review, read “Letters that Matter” by John Zuern.

I started this blog with this collection because I knew it was full of quality work, and I’m grateful to the poets that crafted these experiences and to the editors who chose them and curated them so well. Now onward to the Electronic Literature Collection, Volume 2!