Gomringer’s Untitled Poem [“silencio”], an Unlikely Sonnet

The untitled poem by Eugen Gomringer that we can only call “silencio” is a classic, perhaps the classic, concrete poem. According to Marjorie Perloff’s Unoriginal Genius, the “silencio” version of the poem dates from 1953. In my 1968 edition of The Book of Hours and Constellations I find the German manifestation of this poem (with the word “schweigen”) and the English poem (with the word “silence”), on the same page at the very beginning of the book — but no “silencio.” The place where I do find “silencio” is An Anthology of Concrete Poetry from 1967, edited by Emmett Williams. My copy is the re-issue by Primary Information.

Williams mentions tendencies and tries not to too strongly characterize any particular poets in the anthologies when he writes, in the introduction:

The visual element of their poetry [the concrete poets’ poetry] tended to be structural, a consequence of the poem, a “picture” of the lines of force of the work itself, and not merely textural. It was poetry beyond paraphrase … the word, not words, words, words or expressionistic squiggles …

There are several essential points here about the project of concrete poetry and how it differs from, for instance, the shapes of “Easter Wings” and the other poems in George Herbert’s The Altar, as well as the way Lewis Carroll presented the image of a mouse’s tail in words that tell the mouse’s tale in Alice’s Adventures in Wonderland. However brilliant these two writers were, in these cases they were using language to make pictures; the concrete poets, beginning with Gomringer, worked to create structures. Their poems are not just verse (lineated language), but made from lines of force. In many cases, as with the unnamed poem I must call “silencio,” an entire concrete poem can be understood to cohere as a word.

There are other interpretations of Gomringer’s poem that situate it in history, but I will give a simple one that situates it within the project of concrete poetry — followed by another that places it in a different and much longer-lived poetic tradition.

The lines of force of this poem are, most obviously, those that allow for the gap in the middle where the ground (the absence of text, the absence of “silencio”) becomes figure. As ink declares silence, or, if we read the text aloud, as our voice declares silence, attentive readers can’t help but notice a truer silence in the middle of the page.

At the next stage, there is silence between each “silencio,” horizontally and vertically. We overlook this gap, which is seen even when text is not presented on a grid. It too will be represented if we read the poem aloud, however, between each spoken word.

We can go further, although ear and eye would not agree about the silences. There are spaces, and thus silences of a visual sort, between each of the letters in “silencio,” too.

Fascinating, isn’t it, that John Cage’s 4’33” was composed and presented in 1952, preceding this poem? This poem, too, seems to structurally show, through its lines of force, that silence can take center stage.

In any case, without offering more than a brief appreciation, I mean to make it clear that this is a quintessential concrete poem. One can read it out loud, but that does not provide the listener with the effect of apprehending the structure of the poem on the page. The poem is not a picture of anything. It is a structure. And it is not squiggles or simply a bunch of words, even if the single lexeme “silencio” is repeated fourteen times. It is fitting to apprehend and read the whole poem as a word, not a bunch of words.

Accepting this, I would like to offer an interpretation of this poem that may seem perverse, but which I believe shows this poem’s radical versatility: It can be seen in the light of a poetic tradition that long predates concrete poetry. This poem is not only a concrete poem, but also a sonnet. Specifically, I’ll argue that although the repeated word is a Spanish word, it fits into the English-language tradition of the sonnet. Because concrete poetry is a transnational phenomenon and Gomringer writes in English as well as German and Spanish, this disjunction may be less unusual that it otherwise would be.

Consider that the poem consists of fourteen occurrences of “silencio,” which despite their unusual arrangement on the page can be read aloud as fourteen lines. It would be hard not to read them this way.

Because each word is the same, the poem follows the rhyme scheme of a sonnet — any rhyme scheme, including the Petrarchan or Shakespearean in English, including those typical in Spanish.

If some reader finds it impossible for the same line to be repeated fourteen times in a sonnet, I refer this reader to the 2002 “Sonnet” by Terrance Hayes, which consists of fourteen repetitions of the line “We sliced the watermelon into smiles.”

But is it metrical? The word “silencio” pronounced by itself has two metrical feet ( x / | x / ) and is in perfectly regular iambic dimeter. This is also the meter of Elizabeth Bishop’s last poem, “Sonnet,” which begins:

Caught — the bubble
in the spirit level,
a creature divided;
and the compass needle

There’s much more variation in Bishop’s poem, but the metrical regularity of Gomringer’s poem shouldn’t preclude it from being in this particular form. While I don’t have an example of a sonnet with repeated lines (like the one by Hayes) from before 1953, there are earlier sonnets in dimeter, or one, at least: a piece of light verse by Arthur Guiterman, published in The New Yorker on July 7, 1939.

Sonnets can be about anything, although the form does have a heritage. Reading the poem as a sonnet allows us to make a connection to the sonnet tradition if we wish. We can, for instance, ask whether this sonnet has anything to do with love, whether in the most traditional sense of love for a woman or, in John Donne and Herbert’s senses, religious love. Could the silence of this sonnet be that of being understood, and of not needing to say anything aloud?

Seeing this Gomringer poem as a sonnet also allows us to put it into conversation with other one-word texts (those that have several tokens but repeat a single type) that can also be viewed as sonnets, because they have fourteen tokens.

The one I know of, and which fascinates me, is Dance, a typing by Christoper Knowles that I saw contextualized as visual art in his 2015 solo show at the Philadelphia ICA. The page of this work is blank except for a line at the top that repeats the word “DANCE” (in capital letters) fourteen times, with a space between each occurrence. This makes for 83 characters: 5 × 14 = 70 for the word DANCE, plus the 13 spaces that go between each pair of words. While a sheet of paper is typically thought to accommodate 80 typewritten characters across its width, Knowles found that by beginning at the extreme left edge of the page and typing to the extreme right edge, he could fit exactly 83 onto it.

The typing Dance can be read as a sonnet in hemimeter — a term used by George Starbuck for “half-feet,” and associated with light verse. Where “silencio” offers a more static and contemplative structure, I can’t help but imagine Knowles typing DANCE repeatedly, his hands dancing on the typewriter, as he also produced a text that is a score, instructing us to dance. Not so much a structure, it seems to me, but an exhortation and a trace of its making. And, of course, a text that can be read in the sonnet tradition, asking us to consider how dance, repeated, insistent, filling the width of the page completely, relates to love.

A Bit about Alphabit

During Synchrony 2019, on the train from New York City to Montreal, two of us (nom de nom and shifty) wrote a 64 byte Commodore 64 program which ended up in the Old School competition. (It could have also gone into the Nano competition for <=256 byte productions.) Our Alphabit edged out the one other fine entry in Old School, a Sega Genesis production by MopeDude also written on the train.

The small program we wrote is not a conventional or spectacular demo; like almost all of the work by nom de nom, it uses character graphics exclusively. But since we like sizecoding on the Commodore 64, we wanted to explain this small program byte by byte. We hope this explanation will be understandable to interested people who know how to program, even if they may not have much assembly or C64 experience.

To get Alphabit itself, download the program from nickm.com and run it in a C64 emulator or on some hardware Commodore 64. You can see a short video of Alphabit running on Commodore 64 and CRT monitor, for the first few seconds, for purposes of illustration.

              starting here,
              these bytes load
at:     02 08 01 00 00 9E 32 30
$0808   36 31 00 00 00 20 81 FF
$0810   C8 8C 12 D4 8C 14 D4 C8
$0818   8C 20 D0 AD 12 D0 9D F4
$0820   D3 8C 18 D4 D0 F5 8A 8E
$0828   0F D4 AE 1B D4 E0 F0 B0
$0830   F6 9D 90 05 9D 90 D9 AA
$0838   88 D0 E0 E8 E0 1B D0 DB

Load address. Commodore 64 programs (PRG files) have a very simple format: a two-byte load address, least significant byte first, followed by the machine code which will be loaded at that address. So this part of the file says to load at $0802. The BASIC program area begins at $0801, but as explained next, it’s possible to cheat and load the program one byte higher in memory, saving one byte in the PRG file.

BASIC bootloader, $0802–$080c: This program starts with a tiny BASIC program that will run when the user types RUN and presses ENTER. When run, this program, a bootloader, will execute the main machine code. In this case the program is “0 SYS2061” with the line number represented as 00 00, the BASIC keyword SYS represented by a single byte, 9E, and its argument “2061” represented by ASCII-encoded digits: 32 30 36 31. When run, this starts the machine code program at decimal address 2061, which is $080D, the beginning of the next block of bytes.

Advanced note: Normally a BASIC program would need at least one more byte, because two bytes at $0801 and $0802 are needed to declare the “next line number.” You would have to specify where to go after the first line has finished executing. But for our bootloader, any non-null next line number will work as the next line number. Our program is going to run the machine code at $080d (decimal 2061) and then break. So we only need to fulfill one formal requirement: Some nonzero value has to be written to either $0801 or $0802. For our purposes, whatever is already in $0801 can stay there. That’s what allows this program to load at $0802, saving us one byte.

On the 6502: There are three “variables” provided by this processor, the accumulator (a general-purpose register, which can be used with arithmetic operations) and the x and y registers (essentially counters, which can be incremented and decremented).

Initialization, $080d–$081a: This sets up two aspects of the demo, sound and graphics. Actually, after voice 3 is initialized, it is used not only to make sound, but also to generate random numbers for putting characters on screen. This is a special facility of the C64’s sound chip; when voice 3 is set to generate noise, one can also retrieve random numbers from the chip.

The initialization proceeds by clearing the screen using the Kernal’s SCINIT routine. When SCINIT finishes, the y register has $84 in it. It turns out that for our purposes the noise waveform register and the sustain-decay register can both be set to $85, so instead of using two bytes to load a new value into y (ldy #$85), the program can simply increment y (iny), which takes only one byte. After storing $85 in those two registers, the goal is to set the border color to the same as the default screen color, dark blue, $06. Actually any value with 6 for a second hex digit will work, so again the program can increment y to make it $86 and then use this to set the border color. Finally, the y register is going to count down the number of times each letter (A, B, C … until Z) will be written onto the screen. Initially, the program puts ‘A’ on screen $86 times (134 decimal); for every subsequent letter, it puts the letter on screen 256 times — but that comes later. The original assembly for this initialization:
    iny         ; $85 works for the next two...
    sty $d412   ; voice 3 noise waveform
    sty $d414   ; voice 3 SR
    iny         ; $86 works; low nybble needs to be $6
    sty $d020   ; set the border color to dark blue
Each letter loop, first part, $081b–$0826: This loop counts through each of the 26 letters. The top part of the loop has a loop within it in which some of the sound is produced; then there is just a single instruction after that.

Fortunately, the x register already is set up with $01, the screen code of the letter ‘A’, thanks to SCINIT. In this loop, the value of the current raster line (the lowest 8 bits of a 9-bit value, to be precise) is loaded into the accumulator. The next instruction stores that value in a memory location indexed by x; as x increases during the run of the program, this memory location will eventually be mapped to the sound chip registers for voices 1 and 2, starting at $d400, and this will make some sounds. This is what gives some higher-level structure to the sound in the piece, which would otherwise be completely repetitive. After this instruction, however many characters are left to put onto the screen (counting down from 255 to 0) goes into the volume register, which causes the volume to quickly drop and then spike to create a rhythmic effect. With the noise turned on it makes a percussive sound. All of this takes place again and again until that raster line value is 0, which happens twice per frame, 120 times a second.

After all of this, the value in x (which letter, A–Z, is the current one) is transferred into the accumulator, necessary because of how the rest of the outer loop is written. The original assembly for the beginning of the outer loop:
raster:
    lda $d012   ; get raster line (lowest 8 bits)
    sta $d3f4,x ; raster line --> some sound register
    sty $d418   ; # of chars left to write --> volume
    bne raster
    txa
Get random, $0827–$0830: This code does a bit more sound work, using the x register to set the frequency. Since this is the current letter value, it increases throughout the run of the program, and the pitch generally rises. Then, a random value (well, not truly random, but “noisy” and produced by the sound chip’s noise generator) is loaded in that x register, with the program continuing to get the value until it is in the range $00–$ef (decimal 0–239). If the value has to be obtained multiple times, frequency gets set multiple times, too, adding some glitchiness to the sound. Because the random value is bounded, the program will place the characters in a 40 character × 6 line (240 character) region.
random:
    stx $d40f       ; current letter --> freq
    ldx $d41b       ; get random byte from voice 3
    cpx #240
    bcs random
Each letter loop, last part, $0831–$083a: In the bottom part of this loop, the characters are put onto the screen by writing to screen memory and color memory. Screen memory starts at $0400, and $0590 is the starting point of our 6-line rectangle in the middle of the screen. The corresponding point in color memory is $d990. Our current character (A–Z) is in the accumulator at this point, while the x register, used to offset from $0590 and $d990, has a random value. After putting the accumulator’s value (as a letter) into screen memory and (as a color) into color memory, the accumulator is transferred back into the x register, a counter. Then the y register (counting down to 0) is decremented. The program keeps doing this whole process, the “each letter loop,” until y reaches 0.
    sta $0590,x  ; jam the current letter on screen
    sta $d990,x  ; make some colors with the value
    tax
    dey
    bne raster
Outer loop, $083b–$083f: This is the code for counting from 1 to 26, A to Z. Since the x register stores the current letter, it is incremented here. It is compared with decimal 27; if the register has that value, the program is done and it will fall through to whatever is next in memory … probably $00, which will break the program, although anything might be in memory there. It would have been nice to have an explicit brk as part of this PRG, but hey, this is a 64-byte demo with a BASIC bootloader, written one day on a train. If the program has more letters to go through, it branches all the way back up to the beginning of the “each letter loop.”
    inx
    cpx #27     ; have we gotten past ‘Z’?
    bne raster

Concise Computational Literature is Now Online in Taper

I’m pleased to announce the release of the first issue of Taper, along with the call for works for issue #2.

Taper is a DIY literary magazine that hosts very short computational literary works — in the first issue, sonic, visual, animated, and generated poetry that is no more than 1KB, excluding comments and the standard header that all pages share. In the second issue, this constraint will be relaxed to 2KB.

The first issue has nine poems by six authors, which were selected by an editorial collective of four. Here is how this work looked when showcased today at our exhibit in the Trope Tank:

Weights and Measures and for the pool players at the Golden Shovel, Lillian Yvonne-Bertram
“Weights and Measures” and “for the pool players at the Golden Shovel,” Lillian Yvonne-Bertram
193 and ArcMaze, Sebastian Bartlett
“193” and “ArcMaze,” Sebastian Bartlett
Alpha Riddims, Pierre Tchetgen and Rise, Angela Chang
“Alpha Riddims,” Pierre Tchetgen and “Rise,” Angela Chang
US and Field, Nick Montfort
“US” and “Field,” Nick Montfort
God, Milton Läufer
“God,” Milton Läufer

This issue is tiny in size and contains only a small number of projects, but we think they are of very high quality and interestingly diverse. This first issue of Taper also lays the groundwork for fairly easy production of future issues.

The next issue will have two new editorial collective members, but not me, as I focus on my role as publisher of this magazine though my very small press, Bad Quarto.

Paging Babel

About 12 hours ago I was reading “The New Art of Making Books” by Ulises Carrión, a text I’d read before but which I hadn’t fully considered and engaged with. As I thought about Carrión’s writing, I felt compelled to put together a short piece on the Web. That took the form of a Web page containing a rapidly-moving concrete poem. The work I devised is called “Una página de Babel.”

Screen capture of Babel

Many will surely note that it is based on Jorge Luis Borges’s “Una biblioteca de Babel” (The Library of Babel). And, I hope people are aware of some the other interesting digital projects based on this story. I have seen one from years ago on CD-ROM; one that is very nice, and available on the Web, is Jeremiah Johnson’s BABEL. There’s also the exquisite Library of Babel by Jonathan Basile.

My piece does not try to closely and literally implement the library that Borges described, although it does have a page that is formally like the ones in Borges’s library: 80 characters wide, 40 lines long. Given this austere rectangular regularity, I assumed a typewriter-like monospace font.

The devotion of “Una página” to what the text describes stops there; instead of using the 23-letter alphabet that Borges sketches to populate this 80×40 grid, I use the unigram probabilities of letters in the story itself, in the Spanish text of “La biblioteca de Babel.” So, for instance, the lowercase letter a occurs a bit less than 8.4% of the time, and this is the probability with which it is produced on the page. The same holds for spaces, for the letter ñ, and for all other glyphs; they appear on the page at random, with the same probability that they do in Borges’s story. Because each letter is picked independently at random, the result does not bear much relationship to Spanish or any other human language, in which the occurrence of a glyph usually has something to do with the glyph before it (and before that, and so on).

“Una página” is also non-interactive. One can zoom, screenshot, copy and paste, and so on, but the program itself does not accept user input.

I sketched the program in Python before developing it in JavaScript, and when I was done with the HTML page that includes the JavaScript program, I thought I’d make a Python version, too. But when I did, I was disappointed; the Python program isn’t a page, and doesn’t produce a page, and so doesn’t seem to me to fit the concept, which has to be that of a page. Thus, I’m not going to release the Python program. The JavaScript version is the right one, in this case.

@Party 2015 Productions

I had five productions (one of them a collaboration) this time around at @Party, the Boston-area demoparty.

Browser demo: “More Tongue.” This was, well, not really a standard demo, even for a browser demo, that generates nonsense poems with compact code. Like everything at demoparties, it’s been released, but I’m going to work on a post-party version, so I’m leaving the party version out of this list.

Wild: “Shortcat.”

Shortcat is a very simple encoding scheme to make bytes (thus computer programs) into pleasing Unicode tweets, IMs, etc. #demoscene

Encoder: cat x.prg | perl -pe 'binmode STDOUT,":utf8";tr/\x00-\xff/\x{2500}-\x{25ff}/;' > x.txt #demoscene

Decoder: cat x.txt | perl -pe 's/[\x00-\x7f]//g;s/\xe2(.)(.)[^\xe2]\*/chr((ord($1)-148)\*64+ord($2)-128)/eg;' > x.prg #demoscene

To decode, copy the Shortcat string to a new text file, save it, decode. ASCII (incl. spaces & newlines) will be ignored #demoscene

When decoding, don’t include other Unicode besides the Shortcat string in your selection #demoscene

Add a hashtag (e.g., #c64) and/or other info (e.g., SYS4096) to help people run the program. That’s it. Nanointros everywhere! #demoscene

Check this Tweet for an example.

Executable music: “Dial Up” by devourant & nom de nom.

((((t\*2^12018^t>>16)&42)\*(t^12)&t>>5)>>3|t\*9&(t&4^42)>>5)-1

Play it in an HTML5 player.

Intro: “Chronon,” a 32-byte Commodore 64 program.

PRG file. Source.

PET Code

Demo: “PET Code,” a 128-byte Commodore 64 program that is a demake of Jörg Piringer’s “Unicode.”

PRG file, demo version (runs once & ends). PRG file, looping version. Source.

Thanks to Metoikos, Dr. Claw, Luis, and other organizers and volunteers for putting this year’s party on – and to Boston Cyberarts and the sponsors of the event.

Steve McCaffery Reading Carnival at Purple Blurb

Steve McCaffery read at MIT in the Purple Blurb series on March 19, 2012. A recording of part of that reading (his reading of Carnival) is embedded above; the text of my introduction follows.

Thank you all for braving the cold to come out today. Did you know that today is officially the last day of Winter? Ever! Winter is officially over forever!

But I come not to bury Winter, but to praise Steve McCaffery, and to introduce him. Steve McCaffery is professor and Gray Chair at the University of Buffalo in the Poetics Program. He comes to us from there, and before, from Canada, where he did much of his pioneering work in sound and concrete poetry. He is one of those people who is know for his non-digital work but without whom the current situation of electronic literature, of digital writing, could not exist. He is in that category, for instance, with Jorge Luis Borges.

You would have me institutionalized for loggorrhea if I attempted to read Steve McCaffery’s entire bibliography and discography to you.

Know, however, that McCaffery was one of the Four Horsemen, along with bpNichol, Rafael Barreto-Rivera, and Paul Dutton. This groundbreaking group of sound poets, numbering almost as many mouths as there are vowels, released several albumbs: “Live in the West,” and “Bootleg,” and “caNADAda.”

McCaffery’s critical writing can found in “North of Intention: Critical Writings 1973-1986” and “Prior to Meaning: The Protosemantic and Poetics” His two-volume selected poems, “Seven Pages Missing,” was published in Coach House in 2000. It earned him his second Governor General’s Awards nomination; his first was for his 1991 book “Theory of Sediment.” More recently, there’s his “Verse and Worse: Selected Poems 1989-2009,” which he and Darren Wershler edited.

And, I’ll mention two other books, his “The Basho Variations,” published in 2007, which consists of different translations and version of Matsuo Basho’s famous haiku, which could be rendered clunkily as “old pond / frog jump in / water sound.” A digital version of this haiku can be seen in Neil Hennesy’s “Basho’s Frogger,” a modified version of the game Frogger in which the first row of floating items is missing so that one can only … you know … jump in. McCaffery is pond and frog and sound, placid and salient and resonant, and we are very lucky to have him here with us tonight.

Finally, I want to mention his extraordinary poem “Carnival.” I’ve taught the first panel to dozens of students here at MIT, so it’s black and red and read all over. The two panels of “Carnival” are incredible documents. If only fragments of them survive in three thousand years, that will be adequate for archaeologists to reconstruct the functioning and history of the typewriter completely. Of course, there’s more to “Carnival” than that material writing technology. But instead of saying more, I should simply let our guest give voice to “Carnival” and other works of his. Please join me in welcoming Steve McCaffery…