t t fileclose0x8154340
$Id:  $

When writing executes itself

Algorithmic self-reflection in the poetry of François le Lionnais, Jodi, Eugen Gomringer, Quirinus Kuhlmann and Graham Harwood.

Florian Cramer

April 21, 2003


Computers and the Internet differ from all other so-called 'new media' in that they are based on formal instruction codes. It thus comes to no surprise that (a) much if not most of the most exciting digital art and poetry of the last few years reflects the aesthetics and poetics of computer codes and (b) in doing so, reveals striking similarities to older concrete poetry and experimental literature. My talk attempts to sketch a history of executable codes in writing from 17th century permutational poetry and 20th century Oulipo/concrete poetry to contemporary, post-Net.art 'codeworks', concluding that the poetics of self-executable writing has shifted significantly since executable code has turned from a hidden and scarce to a visible und abundant cultural resource in the late 1990s.

Poetry and Program Code


The first proposal for writing poetry in computer programming languages was published in 1962 in the first manifesto of the Oulipo, the poets and mathematicians founded by Raymond Queneau and François le Lionnais. The manifesto called upon for advancements in "special vocabularies (such as those by ravens, foxes, fish; the Algol language of electronic computers etc." ("des vocabulaires particuliers (corbeaux, renards, marsouins ; langage Algol des ordinateurs électroniques, etc.)". Still, it took another ten years - until 1972 - that the first poem in a computer programming language was written by the mathematician and Oulipo member François le Lionnais:
Begin: to make format,
go down to comment
while channel not false
(if not true). End.

What reads like a pseudo-haiku which meditates technology instead of nature, or like a piece of concrete poetry in which the title "table" reflects itself, is at the same time a piece of computer sourcecode, written the ALGOL programming language as it had been popular in the 1960s and 1970s. However, the sourcecode doesn't compile and execute. As suggested in the Oulipo manifesto, it rather is a text written in one of many special languages than a text concerned with algorithmics and the borders between language and computation.
Otherwise, the writing would be readable not only in two, but three different ways: First as an English text, second as a sourcecode in a computer programming language, and third as the text/data generated by the sourcecode instructions. In other words: Text becomes executable, and auto-generative by embedding a calculus. (...)
Independently from Oulipo's experiments with ALGOL, programming language poetry became popular in the early 1990s in the community around the Perl scripting language. Coined by Perl creator Larry Wall, Perl poetry took off in the Internet and soon after underwent a systematic taxonomy in Sharon Hopkins' 1991 paper "Camels and Needles: Computer Poetry Meets the Perl Programming Language" http://www.wall.org/~sharon/plpaper.ps. Two Perl Poetry contests in 2000 and 2001 helped to keep the genre alive. But to date, most Perl poetry remains disappointing from literary and artistic points of view. An example, taken from the poem "love.pl":
our $life = \$love and $togetherness;
and: foreach my $sweet (@first) {
    little: until ($we . $met) { last 'and' }
if ($now . $we) {  goto marry; $we . $shall }
bless our $life, More;

In no other digital poetry the relationship of the text and the technology is as intrinsic, to the point, potentially reflexive and virulent as in programming language poetry - given that a program code poem could literally trash a computer (jaromils forkbomb). Yet the sentimentalism and subjective introspection of much if not most Perl poetry passes off as ironic at best and clearly gets tedious over time. So the question is: Is programming language poetry yet another genre of digital art which is conceptually interesting, but suffering from digital kitsch like so much other electronic and so-called multimedia poetry?
Just as the most radical experimental poetry in early modernism was written by visual artists rather than by poets proper, it seems to me as if some of the best digital poetry today is written by net.artists, perhaps because artists have historically been more sophisticated in adapting their work to the specifics of a new material. Which doesn't mean that exciting digital poetry would exist outside the tradition of poetry.
An outstanding example is the newer Perl poetry of Graham Harwood. Harwood is a well known underground and digital artist. In 1988, he co-organized the London Festival of Plagiarism (in which conference participants tENTATIVELY, a cONVENIENCE and Miekal And were involved), in 1989, he began to experiment with artistic modifications of computer games, in 1997, he was the main programm of the experimental web browser end net.art classical I/O/D Webstalker, later he co-founded the Mongrel collective and co-developed the manipulated search engine "Natural Selection". His Perl poem "London.pl" from 2001 is a transcription, or - in programmer jargon - a "port" of William Blake's 1791 poem "London", as indicated by the filename suffix ".pl". Blake's original poem reads:
I wander thro' each charter'd street,
Near where the charter'd Thames does flow,
And mark in every fact I meet
Marks of weakness, marks of woe.
In every cry of every Man,
In every Infant's cry of fear,
In every voice, in every ban,
The mind-forg'd manacles I hear.
How the Chimney-sweeper's cry
Every black'ning Church appalls;
And the hapless Soldier's sigh
Runs in blood down Palace walls.
But most thro' midnight streets I hear
How the youthful Harlot's curse
Blasts the new born Infant's tear,
And blights with plagues the Marriage hearse.
Harwood's text reads as follows:
#       Perl Routines to Manipulate London w.blake@scotoma.org
#       London.pl, v 0.0.0 1792/02/23 08:16:43
#       Copyright (c) 1792-2002 William Blake  
#       Unpublished work reconstituted W.Blake@Scotoma.org.
#       Permission granted to use and modify and append this library so long as the
#       copyright above is maintained, modifications are documented, and
#       credit is given for any use of the library.
#       Thanks are due to many people for reporting bugs and suggestions

#       For more information, see http://www.scotoma.org
#       Grave the sentence deep. My love of London held in torment.
#       Heavy, rains of cruelty, disguised in spectacular investments. 
#       Accumulate interest in Jealousy,Terror and Secrecy.
#       The bloated Square mile 
#       Gifts this isle.
#       In this citys dark gates - the tree of knowledge leads to this mansion built on misery. 
#       Here the dress code of secrecy cloaks the flesh in fear.
#       This is how the proprietary city gets built, 
#       Hidden in every proprietary street, 
#       In every proprietary house, 
#       In every proprietary possession we meet. 

#    London - Simple Act Redress 

#       The American War was the last judgment on England. 
#       Inoculated against the sewer. Albion's Angels 
#       Rise up on wings of iron & steel, spreadsheet & rule: 
#       To gift sanitation & sulphurous fire to: 
#       The wheat of Europe, 
#       The rice of Asia,
#       The potato of America,
#       The maize of Africa. 
#       Massacre-bloated, angels crawl from the corpse of war.
#       Five times fatter than when they entered. 

#       Choking lays the sickening Leveller-republican. Caustic fumes - dusts, 
#       gust from wars - grinding wheels - mills of cruelty - mills of terror, jealousy & secrecy. 
#       Every light ray turned to shadow and despair. to rikets - scabies - ticks & lice. 
#       Until the dark sun never set on the Hanoverian empire. 
#       Rise then the Leveller-republic, rise on wings of knowledge flowing in the domain of the many.
#       For heaven is more knowledge then one man can muster in a lifetime.
#       For hell is more knowledge then one man can muster in a lifetime.

#       This Library is for redressing the gross loss to Londons Imagination of children 
#       beaten enslaved fucked and exploited to death from 1792  to the present.
#       We see this loss in every face marked with weakness or marked with woe. 

use PublicAddressSystem qw(Hampstead Westminster Lambeth Chertsey);
# PublicAddressSystem is an I/O library for the manipulation of the wheelen
# Vortex4 129db outside warning system. 
# from Hampstead in the North, to Peckham in the South, 
# from Bow in the East to Chertsey in the West.

#       Find and calculate the gross lung-capacity of the children screaming from 1792 to the present
#       calculate the air displacement needed to represent the public scream
#       set PublicAddressSystem intance and transmit the output.
#       to do this we approximate that there are 7452520 or so faces that live in the charter'd streets of London. 
#       Found near where the charter'd Thames does flow. 

        local @SocialClass = qw(
                                                CrackKid WarBeatenKid

#       These are a series of anonymous hashes;
#       At least one is required at compile time: 

local %DeadChildIndex;

#       The Data for the DeadChildIndex should be structured as follows:
#       %{DeadChildIndex} => {
#               IndexValue => {
#                       Name            =>  " Child name If known else undefined ";
#                       Age             =>  " Must be under 14 or the code will throw an 
#                                               exception due to $COMPLICITY";
#                       Height                  =>  "Height of the child"
#                       SocialClass             =>  "RentBoy YoungGirl-Syphalitic-Innoculator
#                                               CrackKid WarBeatenKid ForcedFeatalAbortion
#                                               Chimney-Sweeps UncategorisedVictim "
#               }, As many as found
#       }

#       CryOfEveryMan 
#       First we add the Class attribute to the DeadChild instance under review
#       Next add the VitalLungCapacity of that childs ability to scream

        sub CryOfEveryMan {
                my $index = shift;
                # Because a child may belong to one or more SocialClass
                # traverse the list adding the prospects of that SocialClass
                foreach my $Class (@SocialClasses){
                        # Add the contents of this $Class to $DeadChildIndex->{$Index}
                        # Class attribute
                        if( $Class eq $DeadChildIndex->{$Index}->{Class}){
                                $DeadChildIndex->{$Index}->{Class} = %{$Class} ;
                                warn "$DeadChildIndex->{$Index}->{Name} is not a member of = $Class\n";
                $DeadChildIndex->{$Index}->{Class} = %{UncategorisedVictim} if ! $DeadChildIndex->{$Index}->{Class};
                #       The average daily scream output of fear for the period 1792-2002 is 6. 
                my $TotalDaysLived = ($DeadChildIndex->{$Index}->{Class}->{LifeExpectancy} * 365)
                #       Calculate the gross $Lung Capacity For Screaming for this child
                my $LungCapacityForScreaming = &Get_VitalLungCapacity(\%{$DeadChildIndex->{$Index}}) *  $TotalDaysLived;
                # asign to $DeadChildIndex->{$Index}->{ScreamInFear}
                $DeadChildIndex->{$Index}->{ScreamInFear} = $LungCapacityForScreaming;

        #    need a function to play the sound file for 
        #       lenght of time * volume of speaker system * air displacement
        #       The Get_VitalLungCapacity routine uses the Age and Height entry of the DeadChildIndex 
        #       to calculate the Lung-Capacity of the dead child. This is then used to calculate the 
        #       volume and capacity of screams when terrified.
        sub Get_VitalLungCapcity{
                my $DeadChild = shift;
                my (
                        $VitalLungCapcity,      #  vital lung capacity in liters of air 
                        $Height,                        #  is height in centimeters 
                        $Age,                   #  is age in years 
                $Height         = $DeadChild->{Height}      unless ! defined $DeadChild->{Height};
                $Age    = $DeadChild->{Age}                 unless ! defined $DeadChild->{Age};
                if ($Height && $Age){
                        #   lung capacity increases with height, but decreases with age.
                        #   So a person screams the most when they are as tall as they're going to be.
                        #   (Probably about 18 or 20 years old.) 
                        #       This falls outside of our basic parameter of 0 to 14 years. 
                        #       But the calculation is still useful
                        $VitalLungCapacity = ((0.041 * $Height) - (0.018 * $Age)) - 2.69 ;
                        return $VitalLungCapacity;
                        # we may not know the height, try to guess from SocialClass 
                        if(! $Height){$Height   = Get_HeightFromClass(Height => $DeadChild->{SocialClass})}
                        # we may not know the Age, try to guess from SocialClass 
                        if(! $Age){$Age                 = Get_AgeFromClass(Age => $DeadChild->{SocialClass})}
                        if($Age && $Height){
                                $VitalLungCapcity = ((0.041 * $Height) - (0.018 * $Age)) - 2.69 ;
                                return $VitalLungCapacity;
                        #       Approximate it
                        #       The average 6 year old child is about 120 cm tall. So $Height =130.0 and $Age = 6.0
                        #       Put this into our equation and we get that the VitalLungCapacity is about 2.1 liters. 
                        #       The average 14 year old teenager is about 160 cm tall. So Height=160 and Age=14. 
                        #       This gives us a vital lung capacity of about 3.6 liters. 
                                        $VitalLungCapacity = ((3.6) - (2.1) / 8.0) * $Age;
                                        return $VitalLungCapcity;
                                        $VitalLungCapacity = ((3.6) - (2.1) / 8.0) * int(rand(14)) ;
                                        return $VitalLungCapcity;

While the Perl code is syntactically correct and executable in itself, it still does not properly run because it relies upon a non-existing, imaginary software component, namely the module "PublicAddressSystem.pm". 58 of the 189 lines of "London.pl" contain program code, the rest are comments. To Perl-literate readers, it thus looks as if the code was unfinished and parts were missing. Aside from the comments, the sourcecode contains a definition of what in Perl is called an "anonymous array", i.e. a variable storing several values at once, called "@SocialClass", a database (or, in programmer's lingo: "nested hashtable") "%DeadChildrenIndex", and two sub-programs ("subroutines") "CryOfEveryMan" and "Get_VitalLungCapacity". Thus, Harwood's London.pl translates what Blake's poem "London" describes into a symbolic machinery. It is an interpretation of the older poem in a double sense: as code executed by a programming language "interpreter", and as a social-political reading of Blake's poem, focusing the subject onto dead children:
  #       This Library is for redressing the gross loss to Londons
  #       Imagination of children
  #       beaten enslaved fucked and exploited to death from 1792  to the
  #       present.
  #       We see this loss in every face marked with weakness or marked
  #       with woe.

By transcribing William Blake's walk through the city into a program and juxtaposing its walk with the stack-execution of program code, Blake's observations and the woes he tells turn into a macabre process. Which within the sourcecode is described as follows:
  #       Find and calculate the gross lung-capacity of the children
  #       screaming from 1792 to the present
  #       calculate the air displacement needed to represent the public
  #       scream
  #       set PublicAddressSystem intance and transmit the output.
  #       to do this we approximate that there are 7452520 or so faces
  #       that live in the charter'd streets of London.
  #       Found near where the charter'd Thames does flow.

The machine described and set into motion via is imaginary to a great extent, given that the code provides only a fragment of the calculation. But exactly through is fragmentation, it gains its monstrosity: A conflation of writing and machinery using the concept of Perl poetry for something that could be compared to Duchamp's equally imaginary and monstrous bridal machines.


But is calculus inscribed into poetry an invention of digital and programming language poetry? If one would write the history of literature more broadly as a history of text processing, encompassing all kinds of writing practices including religious and mystical next to poetical ones, poetic calculus would begin with the numerological and gematrical codes inscribed Babylonian graveyards (as analyzed in Franz Dornseiff's book "Mystik und Magie in der Sprache"), anagrammatical and word permutational language games as they are known from classical rhetoric and last not least the jewish and christian kabbalah.
It was in the 17th century, with the rediscovery of Ramon Lull's Ars Magna, that these rhetorical and mysticist-speculative traditions coincided; the word-permutational Proteus poetry of, among others, Thomas Lansius, Georg Philiip Harsdoerffer and Quirinus Kuhlmann at once reflected rhetoric, kabbalah and linguistic and philosophical theories of its time which conceived of language and knowledge as a combinatory system. The most systematic and extremist application can be found in the writings of the German late 17th century poet Quirinus Kuhlmann (who ended up travelling as a self-acclaimed mystical "monarch" and "prophet" through Europe and was burned in Moscow as a heretic).
Kuhlmann's poem the "41st Kiss of Love" from 1671 on the ,,change in human matters" expands the form of the one-line word permutational proteus verse to a multi-line word permutational Proteus sonnet.
Auf Nacht / Dunst / Schlacht / Frost / Wind / See / Hitz / Süd / Ost / West / Nord / Sonn / Feur und Plagen /
Folgt Tag / Glantz / Blutt / Schnee / Still / Land / Blitz / Wärmd / Hitz / Lust / Kält / Licht / Brand und Noth:
Auf Leid / Pein / Schmach / Angst / Krig / Ach / Kreutz / Streit / Hohn / Schmertz / Qual / Tükk / Schimpf / als Spott /
Wil Freud / Zir / Ehr / Trost / Sig / Rath / Nutz / Frid / Lohn / Schertz / Ruh / Glükk / Glimpf / stets tagen.
Der Mond / Glunst / Rauch / Gems / Fisch / Gold / Perl / Baum / Flamm / Storch / Frosch / Lamm / Ochs / und Magen
Libt Schein / Stroh / Dampf / Berg / Flutt / Glutt / Schaum / Frucht / Asch / Dach / Teich / Feld / Wiß / und Brod:
Der Schütz / Mensch / Fleiß / Müh / Kunst / Spil / Schiff / Mund / Printz / Rach / Sorg / Geitz / Treu / und GOtt /
Suchts Zil / Schlaff / Preiß / Lob / Gunst / Zank / Port / Kuß / Thron / Mord / Sarg / Geld / Hold / Danksagen
Was Gutt / stark / schwer / recht / lang / groß / Weiß / eins / ja / Lufft / Feur / hoch / weit genennt /
Pflegt Böß / schwach / leicht / krum / breit / klein / schwarz / drei / Nein / Erd / Flutt / tiff / nah / zumeiden /
Auch Mutt / lib / klug / Witz / Geist / Seel / Freund / Lust / Zir / Ruhm / Frid / Schertz / Lob muß scheiden /
Wo Furcht / Haß / Trug / Wein / Fleisch / Leib / Feind / Weh / Schmach / Angst / Streit / Schmertz / Hohn schon rennt
Alles wechselt ; alles libet ; alles scheint was zu hassen:
Wer nur disem nach wird=denken / muß di Menschen Weißheit fassen.
(Short summary: The poem is an allegorical reflection of permutation. The permuting words - monosyllabic substantives - are an inventory of macrocosm and microcosm, derived partly from Lull's tables, from Salomo's proverbs and even intertextually from other 17th century permutational poems. The poem also has linguistic and hermetic subtexts I won't go into the details of here.)
In an afterword, the poet speculates that there are more permutations of the poems than grain of sands in the world and conceives of a "permutation wheel", a proto-computer hardware which would automatically calculate the permutations of the poem. If this wheel is the hardware of Kuhlmann's poetics, the poem is software, or: sourcecode. Generating excessive output from its compact input, it permutes itself syntactically all the while it tells of permutation semantically. It thus creates a unity of signifiers and signified, and words and things. Kuhlmann is quite aware of this when he conceives of himself as a Christian kabbalist seeking to restore the language Adam spoke in Paradise and which, according to the Genesis, allowed him to exert demiurgic power upon the creatures by naming them.
Kuhlmann extended his vision into new foundation of knowledge based on combinatorics and algorithmics. Among others, he conceived of a "ars magna librum scribendi", a "great art of writing books" which would mechanically generate all existing and future books of the world. (A topic that reappears as a parody 50 years later in the Lagado chapter of Swift's Gulliver's Travels, and as an ironic philosophical and poetic speculation in Borges' Library of Babel.)
I digressed into these historical examples of algorithmic sourcecode literature to show that calculus in language and executable code in literature is nothing new, and doesn't even require computing hardware or formalized computer programming languages, as long as there is a formal instruction written into the text. (Other examples are Fluxus scores like those of George Brecht and La Monte Young, or the "Frame Tale" in John Barth's novel "Lost in the Funhouse" which only consists of the sentence "ONCE UPON A TIME THERE WAS A STORY THAT BEGAN" written as an endlessly looping sentence onto a Moebius.)
From Babylonian anagrammatics, Renaissance permutational poetry, 20th century experimental writing to today, I however think there a fundamental paradigm shift has occured with net.art and electronic poetry: Since the mid-1990s, algorithmic sourcecode is no longer a synthetical clean-room construct (even in those cases where it is being used to create collage-like poetry), but has become an abundant good subject to collage and pastiche itself. It is factually the advent of the Open Source/Free Software principle in digital art, and what Alan and other people call "Codework" is exactly founded on that. An example:

jodi vs. Eugen Gomringer

The following text was sent by the net.artists jodi to the rhizome mailing list on Oktober 22nd, 2001. One month after 9/11, it could be read as a commentary to world politics and its discussion on net cultural mailing lists:
$cd ug/models/soldier3
$origin 0 -6 24
$base base
$skin skin

$frame soldierc
$frame soldierd


void() army_fire;

void()  army_stand1     =[      $soldierc,      army_stand2     ]
void()  army_stand2     =[      $soldierc,      army_stand3     ]
void()  army_stand3     =[      $soldierc,      army_stand4     ]
void()  army_stand4     =[      $soldierc,      army_stand5     ]
void()  army_stand5     =[      $soldierc,      army_stand6     ]
void()  army_stand6     =[      $soldierc,      army_stand7     ]
void()  army_stand7     =[      $soldierc,      army_stand8     ]
void()  army_stand8     =[      $soldierc,      army_stand1     ]

void()  army_walk1      =[      $soldierc,      army_walk2      ] {
if (random() < 0.2)
        sound (self, CHAN_VOICE, "soldier/idle.wav", 1, ATTN_IDLE);
void()  army_walk2      =[      $soldierc,      army_walk3      ]
void()  army_walk3      =[      $soldierc,      army_walk4      ]
void()  army_walk4      =[      $soldierc,      army_walk5      ]
void()  army_walk5      =[      $soldierc,      army_walk6      ]
void()  army_walk6      =[      $soldierc,      army_walk7      ]
void()  army_walk7      =[      $soldierc,      army_walk8      ]
void()  army_walk8      =[      $soldierc,      army_walk9      ]
void()  army_walk9      =[      $soldierc,      army_walk10     ]
void()  army_walk10     =[      $soldierc,      army_walk11     ]
void()  army_walk11     =[      $soldierc,      army_walk12     ]
void()  army_walk12     =[      $soldierc,      army_walk13     ]
void()  army_walk13     =[      $soldierc,      army_walk14     ]
void()  army_walk14     =[      $soldierc,      army_walk15     ]
void()  army_walk15     =[      $soldierc,      army_walk16     ]
void()  army_walk16     =[      $soldierc,      army_walk17     ]
void()  army_walk17     =[      $soldierc,      army_walk18     ]
void()  army_walk18     =[      $soldierc,      army_walk19     ]
void()  army_walk19     =[      $soldierc,      army_walk20     ]
void()  army_walk20     =[      $soldierc,      army_walk21     ]
void()  army_walk21     =[      $soldierc,      army_walk22     ]
void()  army_walk22     =[      $soldierc,      army_walk23     ]
void()  army_walk23     =[      $soldierc,      army_walk24     ]
void()  army_walk24     =[      $soldierc,      army_walk1      ]

void()  army_run1       =[      $soldierc,              army_run2       ] {
if (random() < 0.2)
        sound (self, CHAN_VOICE, "soldier/idle.wav", 1, ATTN_IDLE);
void()  army_run2       =[      $soldierc,              army_run3       ]
void()  army_run3       =[      $soldierc,              army_run4       ]
void()  army_run4       =[      $soldierc,              army_run5       ]
void()  army_run5       =[      $soldierc,              army_run6       ]
void()  army_run6       =[      $soldierc,              army_run7       ]
void()  army_run7       =[      $soldierc,              army_run8       ]
void()  army_run8       =[      $soldierc,              army_run1       ]

void()  army_atk1       =[      $soldierc,      army_atk2       ] {ai_face();};
void()  army_atk2       =[      $soldierc,      army_atk3       ] {ai_face();};
void()  army_atk3       =[      $soldierc,      army_atk4       ] {ai_face();};
void()  army_atk4       =[      $soldierc,      army_atk5       ] {ai_face();};
void()  army_atk5       =[      $soldierc,      army_atk6       ]

void()  army_atk6       =[      $soldierc,      army_atk7       ] {ai_face();};
void()  army_atk7       =[      $soldierc,      army_atk8       ]
{ai_face();SUB_CheckRefire (army_atk1);};
void()  army_atk8       =[      $soldierc,      army_atk9       ] {ai_face();};
void()  army_atk9       =[      $soldierc,      army_run1       ] {ai_face();};

void()  army_pain1      =[      $soldierc,              army_pain2      ] {};
void()  army_pain2      =[      $soldierc,              army_pain3      ] {};
void()  army_pain3      =[      $soldierc,              army_pain4      ] {};
void()  army_pain4      =[      $soldierc,              army_pain5      ] {};
void()  army_pain5      =[      $soldierc,              army_pain6      ] {};
void()  army_pain6      =[      $soldierc,              army_run1       ]

void()  army_painb1     =[      $soldierc,      army_painb2     ] {};
void()  army_painb2     =[      $soldierc,      army_painb3     ]
void()  army_painb3     =[      $soldierc,      army_painb4     ]
void()  army_painb4     =[      $soldierc,      army_painb5     ] {};
void()  army_painb5     =[      $soldierc,      army_painb6     ] {};
void()  army_painb6     =[      $soldierc,      army_painb7     ] {};
void()  army_painb7     =[      $soldierc,      army_painb8     ] {};
void()  army_painb8     =[      $soldierc,      army_painb9     ] {};
void()  army_painb9     =[      $soldierc,      army_painb10] {};
void()  army_painb10=[  $soldierc,      army_painb11] {};
void()  army_painb11=[  $soldierc,      army_painb12] {};
void()  army_painb12=[  $soldierc,      army_painb13] {ai_pain(2);};
void()  army_painb13=[  $soldierc,      army_painb14] {};
void()  army_painb14=[  $soldierc,      army_run1       ] {};

void()  army_painc1     =[      $soldierc,      army_painc2     ] {};
void()  army_painc2     =[      $soldierc,      army_painc3     ]
void()  army_painc3     =[      $soldierc,      army_painc4     ] {};
void()  army_painc4     =[      $soldierc,      army_painc5     ] {};
void()  army_painc5     =[      $soldierc,      army_painc6     ]
void()  army_painc6     =[      $soldierc,      army_painc7     ]
void()  army_painc7     =[      $soldierc,      army_painc8     ] {};
void()  army_painc8     =[      $soldierc,      army_painc9     ]
void()  army_painc9     =[      $soldierc,      army_painc10]
void()  army_painc10=[  $soldierc,      army_painc11] {ai_painforward(3);};
void()  army_painc11=[  $soldierc,      army_painc12] {ai_painforward(6);};
void()  army_painc12=[  $soldierc,      army_painc13] {ai_painforward(8);};
void()  army_painc13=[  $soldierc,      army_run1] {};

void(entity attacker, float damage)     army_pain =
        local float r;

        if (self.pain_finished > time)

        r = random();

        if (r < 0.2)
                self.pain_finished = time + 0.6;
                army_pain1 ();
                sound (self, CHAN_VOICE, "soldier/pain1.wav", 1, ATTN_NORM);
        else if (r < 0.6)
                self.pain_finished = time + 1.1;
                army_painb1 ();
                sound (self, CHAN_VOICE, "soldier/pain2.wav", 1, ATTN_NORM);
                self.pain_finished = time + 1.1;
                army_painc1 ();
                sound (self, CHAN_VOICE, "soldier/pain2.wav", 1, ATTN_NORM);

void() army_fire =
        local   vector  dir;
        local   entity  en;


        sound (self, CHAN_WEAPON, "soldier/sattck1.wav", 1, ATTN_NORM);

// dodging player
        en = self.enemy;

        dir = en.origin - en.velocity*0.2;
        dir = normalize (dir - self.origin);

        FireBullets (4, dir, '0.1 0.1 0');

void()  army_die1       =[      $soldierd,      army_die2       ] {};
void()  army_die2       =[      $soldierd,      army_die3       ] {};
void()  army_die3       =[      $soldierd,      army_die4       ]
{self.solid = SOLID_NOT;self.ammo_shells = 5;DropBackpack();};
void()  army_die4       =[      $soldierd,      army_die5       ] {};
void()  army_die5       =[      $soldierd,      army_die6       ] {};
void()  army_die6       =[      $soldierd,      army_die7       ] {};
void()  army_die7       =[      $soldierd,      army_die8       ] {};
void()  army_die8       =[      $soldierd,      army_die9       ] {};
void()  army_die9       =[      $soldierd,      army_die10      ] {};
void()  army_die10      =[      $soldierd,      army_die10      ] {};

void()  army_cdie1      =[      $soldierd,      army_cdie2      ] {};
void()  army_cdie2      =[      $soldierd,      army_cdie3      ]
void()  army_cdie3      =[      $soldierd,      army_cdie4      ]
{self.solid = SOLID_NOT;self.ammo_shells = 5;DropBackpack();ai_back(4);};
void()  army_cdie4      =[      $soldierd,      army_cdie5      ]
void()  army_cdie5      =[      $soldierd,      army_cdie6      ]
void()  army_cdie6      =[      $soldierd,      army_cdie7      ]
void()  army_cdie7      =[      $soldierd,      army_cdie8      ] {};
void()  army_cdie8      =[      $soldierd,      army_cdie9      ] {};
void()  army_cdie9      =[      $soldierd,      army_cdie10     ] {};
void()  army_cdie10     =[      $soldierd,      army_cdie11     ] {};
void()  army_cdie11     =[      $soldierd,      army_cdie11     ] {};

void() army_die =
// check for gib
        if (self.health < -35)
                sound (self, CHAN_VOICE, "player/udeath.wav", 1, ATTN_NORM);
                ThrowHead ("progs/h_guard.mdl", self.health);
                ThrowGib ("progs/gib1.mdl", self.health);
                ThrowGib ("progs/gib2.mdl", self.health);
                ThrowGib ("progs/gib3.mdl", self.health);

// regular death
        sound (self, CHAN_VOICE, "soldier/death1.wav", 1, ATTN_NORM);
        if (random() < 0.5)
                army_die1 ();
                army_cdie1 ();

/*UG monster_army (1 0 0) (-16 -16 -24) (16 16 40) Ambush
void() monster_army =
        if (deathmatch)
        precache_model ("progs/soldier.mdl");
        precache_model ("progs/h_guard.mdl");
        precache_model ("progs/gib1.mdl");
        precache_model ("progs/gib2.mdl");
        precache_model ("progs/gib3.mdl");

        precache_sound ("soldier/death1.wav");
        precache_sound ("soldier/idle.wav");
        precache_sound ("soldier/pain1.wav");
        precache_sound ("soldier/pain2.wav");
        precache_sound ("soldier/sattck1.wav");
        precache_sound ("soldier/sight1.wav");

        precache_sound ("player/udeath.wav");           // gib death

        self.solid = SOLID_SLIDEBOX;
        self.movetype = MOVETYPE_STEP;

        setmodel (self, "progs/soldier.mdl");

        setsize (self, '-16 -16 -24', '16 16 40');
        self.health = 30;

        self.th_stand = army_stand1;
        self.th_walk = army_walk1;
        self.th_run = army_run1;
        self.th_missile = army_atk1;
        self.th_pain = army_pain;
        self.th_die = army_die;

        walkmonster_start ();

Jodi's text is, as you may agree or not, an impressive piece of concrete poetry. Military order has inscribed the grammatical and typographical structure of the text. So it reads like the coded inventory of a weapon's arsenal, like a secret strategic plan, or like a military code language gone autistic.
Compare this to a classical concrete poetry "constellation" of Eugen Gomringer, one of the "three variations to `no error in the system"' from 1969 (in my translation of the German original):
no error in the system
no reror in the system
no rreor in the system
no rroer in the system
no rrore in the system
no rror ein the system
no rror ien the system
no rror ine the system
no rror in ethe system
no rror in tehe system
no rror in thee system
no rror in thee system
no rror in the esystem
no rror in the seystem
no rror in the syestem
no rror in the sysetem
no rror in the systeem
no rror in the systeem
no rror in the systeme
eno rror in the system
neo rror in the system
noe rror in the system
no error in the system
Gomringer's poem could as well be called a programmed text as well. The error as embodied by the letter "e" shifts one position to the right in every next line, thus permuting the text, i.e. shuffling the order of its letters according to a precise algorithm. This algorithm could as well be implemented as a computer program, and indeed Gomringer generated some of his poems with computers still in the early 1970s.
Perhaps you agree with me that jodi's text is better than Gomringer's. It is more complex, more clever and more interesting both as a typographic constellation and as a reflection on language and systems. As some of you may have recognized, jodi's text is - just like the Algol and Perl poems of Le Lionnais and Harwood - a software sourcecode, this time written in the C programming language. While the sourcecode of Gomringer's algorithm is implicit and must be reconstructed by those who read the poem output (which makes it, in my opinion, a tedious and redundant read once you have got its idea) Jodi's and Graham Harwood's texts are interesting both as poem output and program sourcecode, as phenotext (i.e. the text generated) and genotext (the score for the generation of text).
The executable machine code generated from jodi's C sourcecode is, as a matter of fact, their software piece "untitled game" which in itself is a modification of the popular ego shooter game "Quake". In other words: Jodi's concrete poetry is an objet trouvé, a ready-made from program code. Since jodi's obscure the origin and the function of this code in their mailing list posting, the code of Quake/untitled game for the first time becomes readable in its aesthetic and political subtexts.


What are the conclusions to be drawn from this?
©This Text is copylefted according to the Open Publication License Version 1.0 http://opencontent.org/openpub/ and may ne freely copied and used accordingly.