Code as performative speech act

Software art involves an artistic activity which, in the medium —or rather, the material— of software, allows for critical reflection on software (and its cultural impact). It thus highlights the aesthetic and political subtexts of seemingly neutral technical commands. In this article Inke Arns argues that, in the context of software art, a far more interesting notion than the “generative” nature of code is its “performativity”. This notion —borrowed from speech act theory— not only involves the ability to generate in a technical context, but also encompasses the implications and repercussions of code in terms of aesthetics, politics and society. This article proposes the notion of the performativity of code as one of the reasons for contemporary artists’ growing interest in using software as an artistic material.


Introduction
Let's start at the very beginning (I won't spare you this classic). Before discussing my theses, I would like to give you three historical examples of the performativity of speech or texts in general: one biblical, one mythological and one example from Russian Futurism, ie, from the early 20 th century.
According to the Bible, God created the world through speech. God spoke and the world came into being. According to Sefer Yesira (the Book of Creation), God's "speech" was not talking in the sense of someone speaking, but rather a manipulation of the letters of the Hebrew alphabet. These letters, the Book of Creation teaches, are not merely linguistic symbols. They are real. They are made of a special spiritual substance and, hence, could be formed, weighed, shaped, etc. by God. Creation, then, was the process of shaping letters so as to form reality (David R. Blumenthal, 1 The Creator and the Computer article, late 1970s).
A similar, but indeed far more interesting, story for our context is that of the Golem. In 1580 in Prague, as the legend goes, the famous Rabbi Loew created a Golem, an artificial human being made from clay. This artificial mute man was created in order to protect the Jewish people in times of persecution. What is interesting in the context of a "pre-history" of the performative is the fact that this Golem would come alive simply by the Rabbi engraving the word "Emet", or truth, on the Golem's forehead. But as soon as the first letter of the word "Emet" is erased, the Golem immediately collapses. By deleting the first letter Aleph (which represents God, or more generally, the creative power) from the word "Emet", the word now reads "met", , which stands for "dead man", "dead" or "death". Thus, one small letter -aleph-marks the border between life and death, creation and destruction of the clay man -reminding one of the need to stick strictly to orthographic rules when programming: here, the difference between a comma and a semicolon could be fatal. Interestingly enough, when the first computer main-Generative art ≠ software art According to Philip Galanter (2003), generative art refers to "any art practice where the artist uses a system, such as a set of natural language rules, a computer program, a machine, or other procedural invention, which is set into motion with some degree of autonomy contributing to or resulting in a completed work of art". 4 Generative art thus describes processes defined by rules, processes which are automated to a certain degree by the use of a machine or computer, or by using mathematical or pragmatic instructions. By following these pre-defined rules or instructions, once set in motion these "self-organising" processes run independently from their authors or artist-programmers. Depending on the technical context in which the process is unfolding, the result is "unpredictable" and thus less the result of individual agency or authorship, and much more the result of the respective production conditions or, if you wish, the result of the technical ecology of a certain system. 5 Galanter's definition of generative art is, like definitions by other authors, an "inclusive", allembracing and comprehensive definition, leading Galanter to the conclusion that, surprisingly or not, "generative art is as old as art itself". 6 But let's return to the essential feature: the most prominent element in all these attempts to define generative art (in electronic music and algorithmic composition, computer graphics and animation, the Demo scene and VJ culture and industrial design and architecture) 7 is the employment of generative processes for the negation of intentionality. Most generative art is interested in generative processes (and in software or code) only insofar as they generate "unpredictable" events. In this sense, and in this context, software and code are understood as pragmatic tools which remain unquestioned in themselves. Exactly because of this, because of generative art's focus on the negation of intentionality and the fact that its main interest does not lie in the questioning of the tools employed, the notion of generative art cannot be used as a synonym for software art.
Software art, on the contrary, involves an artistic activity which, in the medium -or rather, the material-of software, can be found in Adrian Ward: "Generative art is a term given to work which stems from concentrating on the processes involved in producing an artwork, usually (although not strictly) automated by the use of a machine or computer, or by using mathematic or pragmatic instructions to define the rules by which such artworks are executed." (http://www.generative.net). 6. Galanter, ibid., p. 1. 7. Galanter, ibid., p. 2, calls these four areas the four "main clusters" of generative art. frame was presented in Israel in 1965, the Kabbalah specialist Gershom Scholem named it "Golem" 2 (see the name on the chip).
Another example of the performativity of speech is the Russian Futurist poet Velimir Khlebnikov. 3 It would definitely be rewarding to research this poet's experimental work with language more closely, as he could be considered a kind of precursor to software and code art (Olga Goriunova has already pointed to this fact in March this year). Khlebnikov's "star language" (zvezdnyj jazyk), a kind of universal language which he developed between 1915 and 1922 (the year of his death), and which also included an "alphabet of numbers", is set in the context of early 20 th -century avant-garde experimentation with language, but also very clearly distances itself from all these practices (such as Dadaist sound poetry, zaumnyj jazyk from the Russian Futurists, immaginazione senza fili / parole in libertà from the Italian Futurists, and the Surrealists' écriture automatique). Khlebnikov's "star language" is special because it combines extremely archaic and utopian elements. For example, for Khlebnikov, the first letters of words (and numbers) embody ontological relations linking words to history, time and the cosmos. The "star language" is thus not created at random, but presents (through the letters' ontological relations) a complex system functioning globally and throughout time.
These scarce episodes in a yet to be written history of the performative are entertaining and useful to form the basis of my argument, as I wish to stress the importance of the notion of the performative -in contrast to the notion of the generative, or generative art, which has become fashionable over the past few years. Very often, generative art is used as a synonym for software art which, to my understanding, is not entirely correct. To shed some light on this connection between generative art and software art is thus one aim of this presentation. The other is to propose the notion of the performativity of code as one of the reasons for contemporary artists' interest in using software as an artistic material. The performativity of code in this case refers to its ability to act and perform as in speech act theory. allows for critical reflection on software (and its cultural impact). Software art does not regard software merely as a pragmatic, invisible tool generating certain visible results or surfaces, but on the contrary focuses on the program code itself -even if this code is not explicitly being laid open or put in the foreground. According to Florian Cramer, software art highlights the aesthetic and political subtexts of seemingly neutral technical commands. By doing so, software art can take place on different levels: it can be located at the level of the source code, at the level of abstract algorithms or at the level of the result generated by a certain program code. Thus it comes as no surprise that there is a broad spectrum of software artworks ranging from so-called "Codeworks" consisting predominantly of ASCII-Code (not executables), to experimental web browsers (eg, I/O/D's WebStalker, 1997), and fully-executable programs (eg, Antoine Schmitt's Vexation 1, 8 2000, or Adrian Ward's Auto-Illustrator, 9 2000). In generative art, software is only one material amongst others. Software art, on the other hand, can contain elements of generative art but does not necessarily have to be generative in a strict technical sense (see the "Codeworks"). Software art and generative art can therefore not be used synonymously. Rather, these two notions function in different registers, as I hope to show in the following examples.
My first example is the insert_coin 10 project by Dragan Espenschied and Alvar Freude. As part of their diploma work in 2000/2001, which they carried out under the motto "two people control 250 people", the two media art students secretly installed a web proxy server at the Merz Academy in Stuttgart, Germany, which, via a Perl script, manipulated all the web traffic of students and professors on the Academy's computer network. According to Espenschied and Freude, the aim of this project was to critically assess the "competence and the critical faculty of the users concerning the everyday medium internet". 11 The manipulated proxy server redirected the URLs entered to other addresses, modified HTML code, transformed the content of the latest news on news websites via a simple search-and-replace function (eg, by replacing the names of politicians) as well as the content of private e-mails that were read through web interfaces such as Hotmail or Yahoo!. During four weeks this project manipulated web access for the entire Academy -and remained unnoticed. When Espenschied and Freude announced the project publicly, almost nobody was interested. They even published a simpleto-follow instruction manual which would enable everybody to independently switch off the filter that was manipulating the web content. But only a minority of those affected took the time to make the minor adjustment in order to regain access to unfiltered information. Several months after the end of the experiment web access from most of the Academy's computers was still being filtered.

Artnodes July 2005
Code as performative speech act

Image 1. Insert_coin (2000) by Dragan Espenschied and Alvar Freude
My second example, walser.php (2002) by textz.com/Project Gnutenberg (ie, Sebastian Lütgert), has been called "political" or "literary" 12 software. It could be called anticopyright-activist software, written in response to one of the biggest literary scandals in Germany after the Second World War. The file name walser.php is not only an ironic allusion to the file "walser.pdf", a digital pre-print version of Martin Walser's controversial novel which was distributed by the Suhrkamp publishing house as an e-mail attachment -and later on, due to the unfavourable circumstances, called back by the publisher (nice try: calling back a digital document). Rather, walser.php (or rather walser.pl) by textz.com is a Perl script which, via an appropriate Perl interpreter, can generate a human-readable ASCII text version of Walser's novel Death of a Critic from the 10,000 lines of source code. 13 The source code written in Perl contains the novel itself in an "invisible", machine-readable form and thus can be distributed and modified as free software under the GNU General Public Licence. However, it may be only executed with the written permission of the Suhrkamp publishing house. 14 8 My third example is Maurizio Bolognini's installation Sealed Computers (since 1992). It consists in total of over 200 computers producing and exchanging a continuous flow of random images. These computers are sealed and left to work indefinitely, and remain unconnected to any kind of output device (eg, a monitor). As there is no visible result of what is generated and exchanged by these machines, we are left with a somewhat uncomfortable feeling of an invisible, self-contained performative which cannot be controlled.
While Espenschied and Freude's experiment in filtering and censorship of internet content points to the relatively unlimited potential for control contained in software, walser.php offers a practical solution for dealing with the commercial restrictions which threaten the freedom of information on the internet in the form of Digital Rights Management systems (DRM). While insert_coin temporarily produces a dystopian scenario in the form of manipulated software, textz.com with its walser.php project develops genuinely utopian "countermeasures in the form of software". 15 Bolognini's Sealed Computers, on the other hand, embody the invisible performativity of code as a mute and autistic entity or process.
All of these projects are generative in the best sense of the word. However, neither insert_coin nor walser.php comply with the definitions of "generative art" currently predominating in the field of design. Philip Galanter for example, whom I quoted above, defines generative art as a process contributing to or resulting in a completed work of art. Similarly, Celestino Soddu, director of the Generative Design Lab at the Politecnico di Milano University and organiser of the Generative Art 16 conferences, defines "generative art" as a procedural tool enabling the artist or designer to "synthesize […] an ever-changing and unpredictable series of events, pictures, industrial objects, architectures, musical works, environments, and communications". 17 And finally, the Codemuse website also defines generative art as a process with parameters that the artist should experiment with "until the final results are aesthetically pleasing and/or in some way surprising". 18 What becomes apparent from these quotations is the fact that generative art is interested predominantly in the results created by generative processes. Software in this context is seen and employed as a pragmatic-generative tool or device for the creation of certain results -without being questioned itself. The generative processes brought about by software here primarily serve to avoid intentionality and produce an unexpected, arbitrary and inexhaustible diversity of form. The n_Gen Design Machine by Move Design, submitted to the Read_Me Festival 2003 in Helsinki, or Cornelia Sollfranks' net.art Generator 19 (1999), which at the push of a button generates net art, should be seen as ironic commentaries on "generative design" (mis-)understood in such a way. 20 insert_coin and walser.php go beyond such definitions of "generative art" or "design" insofar as these projects are interested far more in the coded processes generating certain results or surfaces. This interest in the coded processes, or, to be more precise, in the significance and implications of software and coded structures, sharply distinguishes them not only from generative art, but also from many interactive installations of the 1990s which displayed their disinterest in software by hiding the program code in black boxes. Instead, projects like insert_coin and walser.php aim to question software and code as culture, and to question culture as implemented in software. To do so, they develop "experimental software" (in insert_coin a proxy server and in walser.php a Perl script), which not only generates arbitrary surfaces but which critically investigates the technological, cultural or social impact of software. Furthermore, the

Generative art Software art
Focus on the surface ("phenotext") created by Focus on the generative process (set in motion by a "genotext") which a generative process ("black box problem") may generate surfaces or other results Software as a pragmatic/neutral tool serving Software as culture which is being questioned; interest in aesthetic and to create a certain result; the tool itself is political subtexts; software can be "experimental" and "non-pragmatic" not being questioned Software as a pragmatic-generative tool Software or code as a work of its own (possibly experimental) Efficient code ("beautiful algorithms"*) Code as excess, code as extravagance, not necessarily efficient Employment of generative processes in order "Software artists […] seem to conceive of generative systems not as to negate intentionality negation of intentionality, but as balancing of randomness and control.
[…] Far from being simply art for machines, software art is highly concerned with artistic subjectivity and its reflection and extension into generative systems."** (Cramer/Gabriel) Fascination of the generative Interest in the "performativity" of code writing of "experimental software" is closely connected to artistic subjectivity, as can be seen in the use of different private languages, and less so with proving evidence of machinic creativity (whatever that may be): "Code can be diaries, poetic, obscure, ironic or disruptive, defunct or impossible, it can simulate and disguise, it has rhetoric and style, it can be an attitude", 21 as the emphatic definition by Florian Cramer and Ulrike Gabriel states, both members of the transmediale software art jury in 2001. I have tried to set up a somewhat polemical comparison between generative art and software art which you can see in Table 1.
The term "software art" was first defined in 2001 by the Berlin media art festival transmediale 22 and introduced as one of the festival's competition categories. 23 Software art, referred to by other authors as "experimental" 24 and "speculative soft-ware" 25 or "unpragmatic" and "irrational" 26 software, comprises projects that use program code as their main artistic material or that deal with the cultural understanding of software, according to the definition developed by the transmediale jury. Here, program code is not considered a pragmatic-functional tool that serves the 'real' artwork, but rather as a generative material consisting of machinic and social processes. Software art can be the result of an autonomous and formal creative practice, but can also refer critically to existing software and the technological, cultural or social significance of software. 27 Interestingly, the difference between software art and generative design is reminiscent of the difference between the software art that was developed in the late 1990s and the early computer art of the 1960s. The difference can be described as follows: works from the field of software art "are not art created using a computer, but art that takes place in the computer; it is not software programmed by artists in order to create autonomous works of art, but software that is itself a work of art. With these programs, it is not the result that is important, but the process triggered in the computer (and on the computer monitor) by the program code." 28 Computer art of the 1960s is close to concept art in its privileging of the concept as opposed to its realisation. However, it does not follow this idea through to its logical conclusion: the work, executed on plotters and dot matrix printers, has an emphasis on the final product and not the program or process that created the work. 29

Performativity of the Code v Fascination with the Generative
The current interest in software, according to my hypothesis, is not only attributable to a fascination with the generative aspect of software, ie, to its ability to (pro)create and generate in a purely technical sense. Of interest to the authors of these projects is something that I would call the performativity of code. By the performativity of code I mean its ability to act and perform in terms of speech act theory.
I am thinking here of a series of lectures by John Langshaw Austin at Harvard University in 1955. In these lectures, entitled How to Do Things With Words, Austin outlined the groundbreaking theory that language does not only have a descriptive, referential or constative function, but also possesses a performative dimension. 30 According to Austin, linguistic utterances by no means only serve the purpose of describing a situation or stating a fact, but are used to commit acts. Austin's speech act theory regards speech essentially as action and sees it as being effective not on the merit of its results, but in and of itself. This is precisely where speech act theory meets code's assumed performativity: "[when] a word not only means something, but performatively generates exactly that which it names". 31 Austin identifies three distinct linguistic acts in all speech acts: the locutionary, 32 the illocutionary 33 and the perlocutionary 34 act. He defines the locutionary act as the propositional content, which can be true or false. This act is not of further interest to us in this context. Illocutionary acts are acts that are performed by the words spoken. These 'performatives' (that create or do what they describe) are defined as acts in which a person who says something also does something (for example, a judge's verdict: "I sentence you" is not a declaration of intent, but an action). The message and execution come together: here, simply "uttering [the message] is committing an act". 35 This draws attention to the importance of the context of a performative utterance. Illocutionary, or performative, utterances have certain consequences and can either succeed or fail, depending on whether certain extra-linguistic conventions are fulfilled or not. 36 Perlocutionary acts, on the other hand, are utterances that trigger a chain of effects. The speech itself and the consequences of that speech do not occur at the same time. As Judith Butler notes, the "consequences are not the same as the speech act, but rather the result or the 'aftermath' of the utterance". 37 Butler summarises the difference in a succinct formula: "While illocutionary acts take place with the help of linguistic conventions, perlocutionary acts are performed with the help of consequences. This distinction thus implies that illocutionary speech acts produce effects without delay, so that 'saying' becomes the same as 'doing' and that both take place simultaneously." 38 Insofar as 'saying' and 'doing' coincide, program codes can be called illocutionary speech acts.
According to Austin, speech acts can also be acts, without necessarily having to be effective (that is, without having to be 'successful'). If these acts are unsuccessful, they represent failed performative utterances. Thus, speech acts are not always effective acts. "A successful performative utterance [however] is defined in that the act is not only committed," writes Butler, "but rather that it also triggers a certain chain of effects." 39 Program codes, viewed very pragmatically, are only useful as successful performative utterances; if they do not cause any effect (regardless of whether the effect is desired or not), or they are not executable, they are plain and simply redundant. In the context of functional pragmatic software, only executable code makes sense. In software art, nonetheless, non-executable code also has a purpose.
Accordingly, when I speak of the performativity of code, I mean that this performativity is not to be understood as a purely technical performativity, ie, it does not only happen in the context of a closed technical system, but affects the realm of the aesthetic, political and social. Program code is characterised by the fact that here "saying" coincides with "doing". Code as an effective speech act is not a description or a representation of something, but, on the contrary, it directly affects, and literally sets in motion, or even "kills", a process. 40 This "coded perfor-mativity" 41 has immediate and political consequences on the actual and virtual spaces (amongst others, the internet), in which we are increasingly moving and living: it means, ultimately, that this coded performativity mobilises or immobilises its users. Code thus becomes Law, or, as Lawrence Lessig put it in 1999, "Code [already] is Law". 42 This is the reason why software art is more interested in the "performance" than in the "competence" (terms coined by Noam Chomsky), more interested in the parole than the langue 43 (the famous opposition coined by Ferdinand de Saussure). In our context, performance and parole refer to the respective actualisations and concrete realisations and consequences a certain program code has on, let's say, social systems, and not only what it does or generates in the context of abstract-technical systems. In the insert_coin and walser.php projects, the generative is deeply politicalspecifically because changing existing texts covertly (in the case of insert_coin) and extracting copyrighted text from a Perl script (in the case of walser.php) is interesting not in the context of technical systems, but rather in the context of the social and political systems that are becoming increasingly dependent on these technical structures.
Certainly one of the "most radical understanding[s] of computer code as artistic material" 44 can be found in the so-called "Codeworks" 45 and the artistic use they make of program code. "Codeworks" almost exclusively consist of texts which are sent to mailing lists like Nettime or 7-11 in the form of simple e-mails. "Codeworks" make use of formal ASCII instruction code and its aesthetic -without relying on the surfaces or graphical user interfaces usually created by this code. Works by Jodi, Netochka Nezvanova, aka antiorp, and mez 46 thus highlight the existence of a hidden, "invisible shadow world of process", 47 as Graham Harwood has called it. Technically speaking, these "Codeworks" are located at the opposite end of an imaginary spectrum of generativity. However, the status of these languages or these language-like bits and pieces remains ambivalent. In the perception of the recipient they oscillate between the supposed executabil-