\documentclass[oneside,english,12pt]{amsart}
\usepackage{pslatex}
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\usepackage{babel}
\usepackage{url}
\usepackage
[pdftitle={When Writing Executes Itself},
pdfkeywords={Writing, Code, Literature, Art},
pdfauthor={Florian Cramer},
backref=true,
pagebackref=true,
hyperindex=true,
bookmarks=true,
bookmarksopen=false]
{hyperref}
\setcounter{secnumdepth}{0}
\setlength\parskip{\medskipamount}
\setlength\parindent{0pt}
\sloppy


\begin{document}

\begin{verbatim}
$Id:  $
\end{verbatim}

\title{When writing executes itself}

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

\author{Florian Cramer}

\date{April 21, 2003}



\begin{abstract}

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.

\end{abstract}


\maketitle

\section{Poetry and Program Code}

\subsection{London.pl}


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{verbatim}
Table
Begin: to make format,
go down to comment
while channel not false
(if not true). End.
\end{verbatim}

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''
\url{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'':

\begin{verse}
\begin{verbatim}
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;
\end{verbatim}
\end{verse}

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:

\begin{verse}

London

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.

\end{verse}

Harwood's text reads as follows:

\begin{verse}
\begin{verbatim}
# 	Perl Routines to Manipulate London w.blake@scotoma.org
# 	London.pl, v 0.0.0 1792/02/23 08:16:43
#	UNFINISHED
# 	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. 

# NAME
#    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.




#	SYNOPIS and DESCRIPTION
# 	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. 
#	
# 	DATATYPES USED:

	local @SocialClass = qw(
						RentBoy
YoungGirl-Syphalitic-Innoculator 
						CrackKid WarBeatenKid
ForcedFeatalAbortion
						Chimney-Sweeps
UnCategorisedVictim
						
						);


#
# 	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} ;
			}else{
				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;
		}else{
			# 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;
			}else{
			#	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. 
				if($Age){
					$VitalLungCapacity = ((3.6) - (2.1) / 8.0) * $Age;
					return $VitalLungCapcity;
				}else{
					$VitalLungCapacity = ((3.6) - (2.1) / 8.0) * int(rand(14)) ;
					return $VitalLungCapcity;
				}
			
			}
			
		}
	
	
	}

\end{verbatim}
\end{verse}


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:

\begin{verbatim}
  #       SYNOPIS and DESCRIPTION
  #       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.
\end{verbatim}

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:

\begin{verbatim}
  #       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.
\end{verbatim}

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.  

\subsection{Kuhlmann}

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.


\begin{verse}

Auf Nacht / Dunst / Schlacht / Frost / Wind / See / Hitz / Süd / Ost / West / Nord / Sonn / Feur und \emph{Plagen} / \\
Folgt Tag / Glantz / Blutt / Schnee / Still / Land / Blitz / Wärmd / Hitz / Lust / Kält / Licht / Brand und \emph{Noth}: \\
Auf Leid / Pein / Schmach / Angst / Krig / Ach / Kreutz / Streit / Hohn / Schmertz / Qual / Tükk / Schimpf / als \emph{Spott} / \\
Wil Freud / Zir / Ehr / Trost / Sig / Rath / Nutz / Frid / Lohn / Schertz / Ruh / Glükk / Glimpf / stets \emph{tagen}.

Der Mond / Glunst / Rauch / Gems / Fisch / Gold / Perl / Baum / Flamm / Storch / Frosch / Lamm / Ochs / und \emph{Magen} \\
Libt Schein / Stroh / Dampf / Berg / Flutt / Glutt / Schaum / Frucht / Asch / Dach / Teich / Feld / Wiß / und \emph{Brod}: \\
Der Schütz / Mensch / Fleiß / Müh / Kunst / Spil / Schiff / Mund / Printz / Rach / Sorg / Geitz / Treu / und \emph{GOtt} / \\
Suchts Zil / Schlaff / Preiß / Lob / Gunst / Zank / Port / Kuß / Thron / Mord / Sarg / Geld / Hold / \emph{Danksagen} \\

Was Gutt / stark / schwer / recht / lang / groß / Weiß / eins / ja / Lufft / Feur / hoch / weit \emph{genennt} / \\
Pflegt Böß / schwach / leicht / krum / breit / klein / schwarz / drei / Nein / Erd / Flutt / tiff / nah / \emph{zumeiden} / \\
Auch Mutt / lib / klug / Witz / Geist / Seel / Freund / Lust / Zir / Ruhm / Frid / Schertz / Lob muß \emph{scheiden} / \\
Wo Furcht / Haß / Trug / Wein / Fleisch / Leib / Feind / Weh / Schmach / Angst / Streit / Schmertz / Hohn \emph{schon rennt}

Alles wechselt ; alles libet ; alles scheint was zu hassen: \\
Wer nur disem nach wird=denken / muß di Menschen Weißheit fassen.

\end{verse}

(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:


\subsection{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: 


\begin{verbatim}
$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	]
{ai_stand();};
void()	army_stand2	=[	$soldierc,	army_stand3	]
{ai_stand();};
void()	army_stand3	=[	$soldierc,	army_stand4	]
{ai_stand();};
void()	army_stand4	=[	$soldierc,	army_stand5	]
{ai_stand();};
void()	army_stand5	=[	$soldierc,	army_stand6	]
{ai_stand();};
void()	army_stand6	=[	$soldierc,	army_stand7	]
{ai_stand();};
void()	army_stand7	=[	$soldierc,	army_stand8	]
{ai_stand();};
void()	army_stand8	=[	$soldierc,	army_stand1	]
{ai_stand();};

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

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

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	]
{ai_face();army_fire();

};
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	]
{ai_pain(1);};

void()	army_painb1	=[	$soldierc,	army_painb2	] {};
void()	army_painb2	=[	$soldierc,	army_painb3	]
{ai_painforward(13);};
void()	army_painb3	=[	$soldierc,	army_painb4	]
{ai_painforward(9);};
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	]
{ai_pain(1);};
void()	army_painc3	=[	$soldierc,	army_painc4	] {};
void()	army_painc4	=[	$soldierc,	army_painc5	] {};
void()	army_painc5	=[	$soldierc,	army_painc6	]
{ai_painforward(1);};
void()	army_painc6	=[	$soldierc,	army_painc7	]
{ai_painforward(1);};
void()	army_painc7	=[	$soldierc,	army_painc8	] {};
void()	army_painc8	=[	$soldierc,	army_painc9	]
{ai_pain(1);};
void()	army_painc9	=[	$soldierc,	army_painc10]
{ai_painforward(4);};
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)
		return;

	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);
	}
	else
	{
		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;

	ai_face();

	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	]
{ai_back(5);};
void()	army_cdie3	=[	$soldierd,	army_cdie4	]
{self.solid = SOLID_NOT;self.ammo_shells = 5;DropBackpack();ai_back(4);};
void()	army_cdie4	=[	$soldierd,	army_cdie5	]
{ai_back(13);};
void()	army_cdie5	=[	$soldierd,	army_cdie6	]
{ai_back(3);};
void()	army_cdie6	=[	$soldierd,	army_cdie7	]
{ai_back(4);};
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);
		return;
	}

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


/*UG monster_army (1 0 0) (-16 -16 -24) (16 16 40) Ambush
*/
void() monster_army =
{
	if (deathmatch)
	{
		remove(self);
		return;
	}
	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 ();
};
\end{verbatim}

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):

\begin{verse}
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\\
\end{verse}

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{\'e}, 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. 

\subsection{Conclusion}

What are the conclusions to be drawn from this?

\begin{itemize}

\item computer code can artistic material like any other. It by no means
is ``machine code'' in the sense that it would be code not written by
humans and meant only to trigger machine processes.

\item art and poetry using computer code as their material address human
imagination, not machines even if they pretend to do the opposite. (A
pretension which itself is an artistic device.) The sourcecode poems of
Quirinus Kuhlmann, Graham Harwood and jodi are outstanding examples for
such imaginative and even fantastic code, and Gomringer's poem is so
poor in comparison because it is intentionally deprived of imagination.
(There is no aesthetics of the machine itself --- contrary to the beliefs 
of techno-determinist media theory ---, but a cultural imagination
invested into the machines which artists can not only play with, but
also participate in.)


\item Poetry is at once expansion and restraint of media. Since it
exists (i.e. since Archilochos and Sappho), it simultaneously involves
sound (through phonetics), visuals (through typography), semantics
(through the referential function of language), and --- let me add this
--- calculus (numerical structures and formal instruction coded into
language, and be it only in the numerical equivalence of a meter, a
rhyme scheme and arrangement of stanzas). 

Calculus has always been part of text and poetry, although it tends to
be overlooked and is more obscure than phonetics, semantics and even
typography. (Jacques Derrida reflected all this already in 1967 in his
book ``On Grammatology'')

\item Plagiarism and intertextuality could be seen as  
``weak'' form of poetic calculus because it means to consider work as
sourcecode and transform it. Open source/Free Software is the historical
principle of mathematics. Historically, there has never been copyright
on mathematical equations and proofs. The reinvigoration of
calculus in poetry via the computer could also lead to a reinvigoration
of anti-copyright aesthetics. (So it is no coincidence that Graham
Harwood organized the Festival of Plagiarism, that jodi's code is
plagiarism in itself and that several people here at this conference
have historical ties with plagiarist subcultures, like Miekal And.)

\item Computer poetry gives new importance to poetic calculus. A
computer is not a medium itself; it is a calculating device capable of
triggering analog media.  Computer poetry and digital art does not
enrich poetry in regards to its media. Visuality for example is more
opulent in books, paintings or sculptural objects than on screens, sound
poetry is richer when performed by human speakers than by machines as
well.  What computers instead allow is a more complex coupling of media,
which is an effect of mathematical computation/calculus. 

\item Codeworks show that digital poetry might also be about media-independence, since code can take any media form. This, in fact, is the historical virtue of 
literature in general which has been proliferated since several thousand years through several old and new media. Sappho's poetry could be printed as soon as printing was invented, it could be sound-recorded as soon as the grammophone was invented, etc.; so literature in itself is both multimedia \emph{and} media-agnostic. 

I think ''new media poetry`` in contrast has the disadvantage
of limiting and  restraining the multitude of media channels
available for literature, because it is tied to one particular output
technology, maybe even one particular piece of output software or browser plugin. But apart from that personal sidenote, I think Oulipo provides a good model 
for digital poetics where it thinks in the terms of ``constraints'', not
infinite openness, to make poetic imagination possible.  Thus, we could
talk about ``new media poetry'' as a formal constraint instead of
fuzzy and pointless expansion.





\end{itemize}










\copyright{This Text is copylefted according to the Open Publication
License Version 1.0 \url{http://opencontent.org/openpub/} and may ne
freely copied and used accordingly.}


\end{document}
