Poetry and Stuff: A Review of <em>#!</em>
Poetry and Stuff: A Review of #!
In this essay John Cayley reviews Nick Montfort’s #!, a book of computer generated poetry and the code that generated it. Exploring the triangle of Montfort’s programs, the machines that read them, and the output presented for human readers, Cayley situates the experience of reading and writing as intrinsically virtual, powered by its sustained potentiality, rather than its definitive comprehension.
At long last, an electronic book for review! Its title—the beginning of a script—is shebang!—hashbang, pound-bang, hash-exclam, hash-pling! This conjunction of two special characters—ancient in the annals of computation—indicates the beginning of a more or less extended statement, a program, in an all but universal language of programmatology, in the special dialect of the command line. Scripts addressed to the Unix operating system begin with these two characters. They inform other programmers and they tell the system—to all human intents and purposes they tell our computational familiars and prosthetics—that what follows is also, if not primarily, addressed to a machine. If we, as human readers, happen to recognize this compound symbol of power in the universal language of Unix and if we are able to interpret the lines that follow it as code, then we may well be able to understand and anticipate what it is that the script or program promises to do and say. Nonetheless, what follows shebang is chiefly meant to be read by the system, as a program, as a list of commands that will generate a performance, an inscription, an output.
Within this book, printed on its pages, there are seventeen examples of such scripts themselves along with many more pages printed with “writing” that has been generated by the scripts. In his acknowledgements, Montfort states that “[t]he poems printed in this book consist of computer programs followed by output from running these programs.” This, then, is a book of poems, produced and published by a well-regarded small press, one which has been making, in editorial terms, a significant investment in the conceptual literary practices that have all but entered the poetic mainstream in recent years, having already been warmly embraced by the art world. Craig Dworkin supplies a foreword in which he reads Montfort’s “The First M Numbers” as “a hilarious riff on conceptual writing.” Hilarity here is dependent on readers getting an allusion (supplied by Dworkin and cited in Montfort’s acknowledgements) to Claude Closky’s alphabetic (re- or dis-) ordering of (names for) the first thousand numbers. Clearly, as Kenneth Goldsmith would have it, to better appreciate these conceptual moves, we must become some part of a “thinkership”—rather than a “readership”—as we begin to derive our literary pleasures from texts that inscribe this variety of heady, cross-categorical allusion, however witty. But Montfort’s “poem” is not just or only an essay in lo-fi conceptualism. His poem—in this case as for all the other pieces in the book—is also a program, one that generates all of the Roman numerals from “I” to “M” and then orders them alphabetically. The program, a mere twenty-one lines of crafty Python, is a part—the main part?—of what Montfort has made. The output is a “trivial” consequence of the script, but it is, nonetheless, printed in the book and proposes, far more overtly than the program, its hilarious remediation of Closky. Which facet of the “poem” makes the joke? The program or the output? Does the elegance of the programming render the output(?), the poem(?), its wit(?), its statement(?) “better”? Does it matter that Montfort, as author, considers the “poem” that he’s made to consist of both program and output?
It matters. The output of “The First M Numbers” is, perhaps, hilarious, and it is certainly a remediation of conceptualism, entirely within its purview. The program is something else. It is an essential prerequisite of the special literary practice in which Montfort engages. I once summarized the argument of an early ebr essay in its title: “The code is not the text (unless it is the text).” In Montfort’s work—especially when presented in this format, as book—the code is a (constitutive) facet of the poem. It is (also) the text. There is no question but that in work such as this, the code must be appreciated, in an extended practice of human reading, even as its execution is, simultaneously, delegated to a computational machine and even where the machine’s generative “reading” produces further opportunities for human reader- and thinkership. Montfort’s poems are not, therefore, instances of conceptualism. What are they?
One answer might be to say that they are instances of electronic literature, electronic poetry. At long last, an electronic book for review! Well, the book is obviously not “electronic.” It’s a printed book. But, by contrast with the vast majority of work that is given the label “electronic literature,” the work in Montfort’s #! is, arguably, worthy of such a designation. Most of what currently comes under the dominion of electronic literature is (time-based) concrete poetry, (time-based) visual poetry and prose, affective audiovisuality constructed with unread or unreadable linguistic material, (more or less conventional) literature illustrated by computationally rendered audiovisual media, (more or less conventional) literature navigated by computational affordances, and so on. This is not meant to be an exhaustive list and there is no intention to denigrate these vital, new—and highly divergent—literary practices. I’m simply suggesting, as I have before, that it is difficult to understand the “electronic” of “electronic literature” and that it might be better to reserve the term for specific varieties of literary practices—like Montfort’s—in which the technical and computational is constitutive, rather than instrumental or decorative (Cayley, “Weapons”). My point relates to the sense that “electronic literature” was coined by analogy with “electronic music.” The latter is now established, solidly instituted—and we are comfortable with its usage in English. We bracket our understanding that, as an artistic medium, electronic music is not electronic: it’s organized sound: abstract, aestheticized aurality. “Electronic” renders the phrase metonymic by referring to technologies that, typically, are designed to produce “electronic music.” In the case of “electronic literature,” these technologies—unless we are to comprehend bespoke electronic voice synthesis, for example—are all, in fact, computational, programmable media. In #! the technologies appropriate to Montfort’s work are deliberately set aside, allowing both programs and samples of generated, virtual language to gain focus and subject themselves to human reading.
In the last analysis, questions of naming will work themselves out in the language games of the communities where these names circulate. Montfort’s practice of programs-plus-output may well find other suitable designations. In the meantime, it is remarkable to discover an epitome of literary computational minimalism stunned and printed in a material cultural apparatus which is entirely unable to realize the potential of its procedural, generative dynamism. And yet—paradoxically, skewmorphically, and as matter-of-fact—it’s more of an “electronic book,” I’d say, than the “electronic book review” you’re reading now.
For a start, given that this is a book of programs designed, in the first place, to run on programmable computers, this book is strangely complete in itself. It contains nearly everything that it needs to be what it is. We might take a moment to compare the circumstances of this book—in respect of its being “complete” and “self-contained”—with those of a conventional literary work. We assume and accept that books of poetry or prose are what they are, precisely and obviously: complete and self-contained. They are published as such by their authors along with the appropriate institutions of dissemination. And yet, to exist as works of literature, these books must be read by other human readers, who interpret the language “contained” within the books so as to generate complex images—complex configurations of signification and affect—in the “minds” of these readers. It is clear that the images, whatever else you may say of them, are far from being “contained” within the book or, for that matter, “within” the linguistic materiality that is, perhaps, “contained” within the book.
At first we might say that the circumstances of #! are entirely different. If the content of #! were to be faithful to its media specificities, then—along with the rest of the world of electronic literature or digital language arts—it would exist and run in and on programmable computers with audiovisual peripherals. As a matter of fact, the majority if not all of the work in this book has been made available online in a form allowing, typically, any of the programs to be cut and pasted into script editors or directly into the terminal windows of most computers where they will simply run and, more or less instantaneously, produce instances of the “same” output that is printed in #!. Montfort’s works of electronic literature have already more than adequately proved their media specific credentials. But note, these particular programs do not require computers to interpret or transcode their output into other media in the sense of the dynamic audiovisuality that is our default expectation, an expectation that can only be satisfied by more and more powerful screen-equipped desktop, home-cinema, and mobile infrastructures. Montfort’s programs produce output that is quietly commensurate with the media in which its generators have been composed: syntactically organized strings of conventional symbols, of characters within the (extended) alphabetic (as it happens) sets that are—significantly but arbitrarily—coincident with the letters we use for writing and for the printing and production of books, in the European culture sphere.
So let’s “read” these poems. We’ve already considered “The First M Numbers” as a way of distinguishing what Montfort does from conceptualism per se. The bulk of #! consists of two series, “Concrete Perl”—four programs-plus-output; and “ppg256”—seven pieces. “Concrete” gives away the aesthetic of the output “texts” in the first series. As output, these texts are to be interpreted as (time-based) visual artifacts, generated from linguistic elements, and interpretable as such in relation to their titles, that is, with reference to human-composed language encapsulating the kind of author’s guidance that is often provided for such work, ensuring that we understand it, at least, in some manner of relation with the author’s own conception. The program in “All the names of God” will generate every permutation of the lower case roman letters a-z, starting with single-letter instances and (never-)ending at some bad or good infinity of an infinite number of infinitely long sequences of these letters, all separated by a commensurate infinity of underscores. “Alphabet Expanding” inserts more and more space between the letters as it prints a-z over and over, endlessly revealing intriguing graphic patterns as a function of interferences from the regularities of the material cultural forms that are implicated with “printing out,” whether this is on (computer-)screen or onto the (virtual) pages of a book. “ASCII Hegemony” endlessly makes a simple statement about the printable characters (and the “space” character) from the (in)famous character set that still underpins the regime of computation. “Letterformed Terrain” is the most (pseudo)random of these pieces—random letters randomly spaced—although again—as for “Alphabet Expanding”—generating something that is interpretable—the title proposes a “terrain”—as a function of the material culture of printing (out). All these programs loop infinitely and, when run on a computer, they would all, if allowed to continue without interruption and with unrestricted access to the computer’s resources, occupy these resources fully until the computer was rendered useless, sated, and fatally “crashed.” For all of these poems-plus-output, the significance and affect of the piece is more or less exhausted by the concept encapsulated in each title with, perhaps, the exception of “Alphabet Expanding,” which continues to be graphically intriguing, even compelling, long after its conceit has been grasped. The shifting in and out of “phase” or graphic “resonance”—as growing space between the letters changes the relation of their serried ranks with the constraints of the output devices’ rows and columns—is strangely pleasing, in the way that moiré patterns are intriguing or disturbing to the eye. However the same effect would be revealed if abstract characters or wingdings were printed instead. More persistent significance and affect for these programs-plus-output reside in the virtuosity of the program. They are willfully constrained to be written in only thirty-two characters of Perl. The code is highly compressed, obscure(d), recondite. Human reading and appreciation of this code—or also, for some, the inability to read it that is a function of its special virtuosic concision—would seem to be important, if not essential, for any critical evaluation of these poems, particularly a positive evaluation, appreciative of the time, effort, and sometimes wit that has gone into the processes of composition.
The seven works of “ppg256” share a structurally similar arbitrary constraint with the works of “Concrete Perl.” These programs, also in Perl, must be less than 256 characters in length, 2 to the 8th power, rather than 2 to the 5th. The extra power allowed to the programmer-author renders the poetic output “generative” rather than “concrete.” “ppg” stands for “Perl Poetry Generator,” indicating that these programs are able to generate output texts that we should be prepared to read as poetry, as poetic. They seem to achieve this effortlessly and, for the most part, endlessly, since, with the exception of “ppg256-7,” they all conclude with the Perl “redo” keyword—a concise infinite loop-maker. “ppg256-1” churns out tiny poems with titles. Titles begin with the word “the,” guaranteeing that we (readers of English) tend to read any following sequence of letters as a plural or singular noun. Montfort’s code generates English words or word-like forms by randomly dipping into long strings of carefully (humanly) paired letters and joining the pairs into four-letter words or word-like (pronounceable) four-letter sequences or (and this is human-smart) consonant+vowel plus consonant+ “s” four-letter sequences that introduce the semantic variations of both plurality (often) and verbal function (more rarely).Three-letter output words are also infrequently possible since any “au” or “ae” mid-word literal collocations are replaced with “a.” For a “line” of “ppg256-1” poetry we need two of these (usually) four-letter word forms joined with a randomly chosen “attoonnoof.” that is: “at/to/on/no/of.” Many of the possibilities are demonstrated by the second-printed poem:
There is so much going on here, generated from such simple, but well-constituted rules. We read “bans” as verbal (although it could also be a noun). We are given extra, rhythmic complexity because “coed” is read in American English as bisyllabic. The title—pure chance—encourages us to strive for a naturalistic, metaphoric, perhaps even narrative reading of the “poem.” The coat covers up and gives warmth but still allows the hack to penetrate. See! It allows its very name to be hacked—as “moat” or “poat”—by nonsensical initial letters and then it (the coat) mashes the female form, even to the extent of her hem-ravaged hams.
Obviously I’m over-reading. No intentionality, human or otherwise, commensurate with that of the reading I have just proposed, could possibly have been anticipated by either the pseudorandom dice-thrower built into all our computational devices or by the human agency, Montfort, who has now nonetheless published both his program and this brief poetic fragment in a form where it can, for all this, be read—in the way I have read it, or in any way that you may now choose to read it as quoted above. Or rather: I am confident that Montfort did not anticipate “the coat” as printed, while I am equally confident that he knew that many such felicitous problems for human reading would be generated by “ppg256-1.” That’s why he made his careful analysis of four-letter sequences in English and condensed his research into a tiny instance of symbolic magic. That’s why he made this “poem” in the sense of program+virtual or actual output rather than in the sense of some particular instance of output or authored language.
One might continue to give similarly extensive and detailed close readings of both programs and output for the entirety of the “ppg256” series, but that would be a task beyond the scope of the present review. Suffice it, here, to remark this possibility, and then provide some brief comments on the rest of the series. Throughout “ppg256” Montfort insists on his arbitrary 2-to-the-8th programmatic concision but goes on to provide generators with: greater variation of line, rhythm, apparent sense, adherence to orthographic English, and a kind of palette of diction—all in “ppg256-2;” simple narrative form and character—in “ppg256-3;” imperative address targeting a gallery installation—”ppg256-4;” polemic aphoristic poststructural-isms-generation and self-reflection—”ppg256-5;” and some sort of return to visual poetics and the evocative combinatorial—in “ppg256-6.” “ppg256-7” is, apart from the usual 256-character limit, a markedly divergent gesture. It exploits the self-reflexive potential built into the Perl language itself along with abbreviated representation of a relatively simple recursive syntactic construction in English to code an artifact that alludes outside its own generative textual domain and into the desolate heartland of English avant-garde writing. The program is able to extract from its constituent computer language the names of fundamental primitives in Perl—variable, literal, special variable, element of an array, element of a hash—assigning each to each along with all their possible concatenations. The “Sometimes he assigned to…” and the permutational syntactic structure make direct, resonating—and fully intentional—reference to the passage in Samuel Beckett’s Watt (a prime supply text for Montfort in a number of his works, such as “Nanowatt” and “Megawatt”) where the decking out of Mr. Knott’s feet is exhaustively considered in the narration, through the permutation and overlayering of—sock, stocking, boot, shoe, and slipper:
As for his feet, sometimes he wore on each a sock, or on the one a sock and on the other a stocking, or a boot, or a shoe, or a slipper, or a sock and boot, or a sock and shoe, or a sock and slipper, or a stocking and boot, or a stocking and shoe, or a stocking and slipper, or nothing at all. And sometimes he wore on each a stocking, or on the one a stocking and on the other a boot, or a shoe, or a slipper, or a sock and boot, or a sock and shoe, or a sock and slipper, or a stocking and boot, or a stocking and shoe, or a stocking and slipper, or nothing at all. And sometimes he wore on each… (173-4)
“ppg256-7” is not really a generator in the sense of one that appears to be—for human readers—open-ended in terms of its output. “ppg256-7” is—like “Round,” “I am that I am,” and “The first M numbers”—clearly deterministic, the generator of a specific artifact, in this case a minimalist tour de force of, at one and the same time, self-reflective formalism and high literary allusion.
To mess with the equivalences of digits and words in “Round” would risk pitting one’s wits against that of an author who has offered us all an elegant and generative conceptual work of computational literature. That would surely be hubris, although it is something that Montfort both invites and encourages since most, if not all, of his work is published with actual or implicit license allowing copying, reuse, and modification so long as attribution and the same licensing terms are maintained. For other generative works in this collection, the invitation to modify the code is openly extended. #!’s purest and most condensed examples of literary generative works are, perhaps, “ppg256-1 thru 6.” Technically, their output is finite. Left running for a long but finite length of time, they would output all the possible combinations of elements encoded within them according to their in-built syntactic rules. As we progress from 1 thru 6 in the series, we detect—we are able to read—higher levels of structure in smaller numbers of elemental possibilities. “ppg256-1 & 2” come across, through the apparent exuberance of their output, as truly generative: offering so many unexpected combinations, as if from nothing and nowhere. In them, it seems impossible to separate “data” from “code” as we struggle to interpret the “text of the code.” It is as if the code itself is the generator of text. Later in the series, we can more easily distinguish, still within the code as such, regions that we can read as “data” or “input.” These are parts of the code within which we might intervene, replacing the existing “data” or “supply text”—of the author’s, of Montfort’s—with our own. For “Taroko Gorge” this potentiality took off. The version printed here is the original, but “Taroko Gorge” has by now become as much a form as a work, since over twenty-five other human authors, many of them prominent figures in the world of digital literature, have taken Montfort’s code and filled it with with their own words and phrases, often adding syntactic and topical gestures, and more rarely new code. As printed here, in Python, the Gorge code is pared down if not obfuscated. The data—word lists—are clearly distinguishable by contrast to single letter function names—which might well have been rendered expressive—within the code. Here Montfort’s inclination towards programmatic concision is still in evidence, whereas the code of “Ruby Yacht” is expressive to the extent that, for many human readers, executing the code itself will be all but unnecessary. As printed, the code generates only six quatrains, each following a rhyme scheme based on Edward FitzGerald’s translations of verses attributed to Omar Khayyám, The Rubáiyát (this word’s Arabic root is “four”). Montfort has launched his poem onto the network, afloat on one bejeweled trans(computer)lingual pun and on another that is, at most, an arbitrary vessel. (This appears, by the way, to be characteristic of Montfort’s underlying style.) If we examine the six verses of output text and compare the program of the verso page opposite, it is clear that many potential combinations and sequences have not been realized. In the output text, the a_phrases items “aureate” and “alchemist” (and a number of others) do not appear, for example. The poetry of Khayyám remains buried in a Ruby fragment. Does this imply that the (text of the) code is more expressive, more poetic than the text that is output? If we read the code and assemble the verses—where and how and when?—in our minds, is this the virtual (I might have written “actual”) poetry of “Ruby Yacht?” Or should we copy the code, set it up in our digital familiars, and keep it running until its all but boundless possibilities have been exhausted, with this literally un(humanly)readable mass of language giving true (actualized) expression to this one small work’s potential poetry?
These, I believe, are deep questions that anyone interested in computational literary practice must consider. Does language exist if it cannot be humanly read? Is the ontology of language bound up with cultural practices that are specifically human? My own current position is that a potential for human reading—which may be virtual—is required to produce an event of language, its existence. As such, #! presents us with a paradoxical circumstance. This book is, with a little learning, exhaustively readable. None of the programs are, ultimately, too complex or abstruse to be judged unreadable, even by amateurs. “Ruby Yacht” is, perhaps, the best example of what I mean. More or less anyone today can read this code and would be able to anticipate, imagine, compose (in the mind) actual verses that the code can generate. “Ruby Yacht” and the other programs in this book are virtual linguistic and, arguably, poetic events. But if we actually run the code, purported “language” will be generated at inhuman speed and in literally unreadable quantities, much of it “language” that many of us would be reluctant to spend any time or effort to comprehend even if we had this requisite time and energy (Cayley, “Reading”). Does this generated language exist as such? Or will its potentiality simply help us to better understand what reading and what writing and what language is? This is the very stuff of poetry.
Beckett, Samuel. Watt. Paris: Olympia Press, 1952; London: Calder Jupiter Books, 1963. Faber and Faber: London, 2009. 173-4.
Cayley, John. “Reading and Giving—Voice and Language.” Performance Research 18.5 (2013): 10-19.