\title{Exe.cut[up]able statements: The Insistence of Code}\author{Florian Cramer}

\documentclass[oneside,english,12pt]?{amsart} \usepackage{pslatex} \usepackage[T1]?{fontenc} \usepackage[latin1]?{inputenc} \usepackage{babel} \usepackage{url} \setcounter{secnumdepth}{0} \setlength\parskip{\medskipamount} \setlength\parindent{0pt} \sloppy

\begin{document}

\title{Exe.cut[up]?able statements: The Insistence of Code}

\author{Florian Cramer}

\date{May 30, 2003}

\maketitle

\section{Tools and writing}

Friedrich Nietzsche's aphorism that ``our writing tools are also involved in writing our thoughts'', put down in the late 19th century after he first used a mechanical typewriter, has become a famous saying in contemporary media theory. Applied to computer code and art, it could also be phrased into a question: How does code shape the aesthetics of digital art and technology?

``10 Programs written in BASIC ©1984'', the title of a solo show of the digital artists Jodi in Malmö/Sweden, June 2003, may be read as a programmatic statement, leading the digital arts back to the future. Consisting of vintage Sinclair ZX Spectrum computers running, quote, ``ten programs in BASIC that the visitor can add and change things to'', the exhibition shows jodi's work at a radical peak of a development that began with net art and continuously evolved from web browser manipulations through HTML data, manipulations of computer games in sourcecode to increasingly abstract ``variations'' of simple BASIC program code, dismantling the fact that, despite the boom of graphical user interfaces in the 1980s and 1990s, program code still is at the heart of computing and digital information technology and hasn't structurally changed since 1984, the year the Apple Macintosh computer. While artists used to run software code in black boxes to drive work that didn't show the programming involved -- interactive video installations, for example --, since the late 1990s, programming and program code have received increasing attention as artistic material in themselves. was first sold. Today, the Macintosh computer has likewise mutated into a flavor of the Unix operating system, exposing its code on a textual commandline interface and thus catching up with contemporary digital arts and its increasing use of computer code as material.

Perhaps the most radical example of computer code turned into artistic material are ``Codeworks'',\footnote{first systematically covered in the ``Codework'' special issue of the American Book Review, see \cite{sondheim:codework}} chiefly E-Mail-based Net.art written in private languages which hybridize English, program and network code and visual typography, like the following:

\begin{verbatim} Exe.cut[up]?able statements -- ::do knot a p.arse.r .make. ::reti.cu[t]?la[ss]?te. yr. text.je[llied]?wells .awe. .r[b]?ust. \end{verbatim}

In these lines, which were taken from the posting ``Re: OPPO.S[able]?.I.T[humbs]?ION!!'' by the Australian net artist mez (a.k.a. Mary Anne Breeze) to the mailing list ``arc.hive'' on January 14th, 2003, the word ,,Exe.cut[up]?able`` becomes a self-descripting executable sourcecode which expands into, among others, ``Exe'' (the Microsoft DOS/Windows file extension for executable programs), ``Executable'' and, recalling the mechanized collage techniques of Brion Gysin and William S. Burroughs, ``cutup''. A poetic employment of computer code which adheres more literally to Unix, Perl or C syntax can be found in E-Mail codeworks of Alan Sondheim, jodi, Johan Meskens and Pascale Gustin.

Aside from the more narrow field of digital art and technology in which code appears as code, it can first be observed that the graphical interface paradigm in end-user software scales only to a limited amount of complexity, thus creating the need for textual scripting extensions and programming interfaces in the software itself;\footnote{``scripting'' being nothing but another word for programming.} secondly, that artists (and also non-artists) who employ software for complex tasks and as part of their thinking and subjectivity tend to push its limits to the point where they start to extend, reprogram or re-implement its code. This tendency manifests itself today in two phenomena, the one being Free (or Open Source) Software as it has gained the attention of a larger public since circa 1998, the other one being software art, a topic in the digital arts since circa 2000, with both discourses intersecting in such projects as runme.org, a software art website created after the model of Free Software download repositories, and sweetcode.org, a Free Software website referencing conceptually (and hence also artistically) interesting computer programs.

\section{Language, not tools}

Proving the insistence of code in computer-based art and technology is not possible, however, if one does not question what computer code exactly is beyond its conventional surface appearance as plain text instructions. Beyond that, software code can be put down in any notation, in flowcharts or graphical simulations of circuitery for example\footnote{such as in the musicial composition frameworks ``MAX' and ``PD'' designed by Miller Puckette}, or simply as a chain of zeros and ones. The problem does not only concern media in particular, but linguistics and semiotics in general: How can the complexity, cultural specificity and oddity of language be boiled down to an easy-to-grasp international system?

The question is much older than computer interface research, having been addressed in, among others, in the Renaissance political and educational utopias of Tommaso Campanella's ``City of the Sun'' and Jan Amos Comenius ``Orbis pictus''. In the ideal city imagined by Campanella, knowledge is purveyed via a graphical user interface:

\begin{quotation}

It is [the book of]? Wisdom who causes the exterior and interior, the higher and lower walls of the city to be adorned with the finest pictures, and to have all the sciences painted upon them in an admirable manner. [...]? There are magistrates who announce the meaning of the pictures, and boys are accustomed to learn all the sciences, without toil and as if for pleasure; but in the way of history only until they are ten years old.

\end{quotation}\footnote{}

The hermetic philosopher and famous educational reformer Comenius translated this idea into the ``Orbis pictus'', the first illustrated children's book and canonical school text in 17th and 18th century Europe, which taught the whole inventory of macro- and microcosm simultaneously through pictures, in Latin words and in the pupils' native language. However, the design flaws of these visual languages, and the dilemma of linguistic operations through graphical user interfaces were addressed still in 1706 in the ``Grand Academy of Lagado'' chapter of Jonathan Swift's ``Gulliver's Travels'':

\begin{quotation}

The other project was a scheme for entirely abolishing all words whatsoever [...]?. An expedient was therefore offered, that since words are only names for things, it would be more convenient for all men to carry about them such things as were necessary to express the particular business they are to discourse on. [...]? However, many of the most learned and wise adhere to the new scheme of expressing themselves by things, which has only this inconvenience attending it, that if a man's business be very great, and of various kinds, he must be obliged in proportion to carry a greater bundle of things upon his back, unless he can afford one or two strong servants to attend him. I have often beheld two of those sages almost sinking under the weight of their packs, like pedlars among us; who, when they met in the streets, would lay down their loads, open their sacks, and hold conversation for an hour together; then put up their implements, help each other to resume their burdens, and take their leave.

\end{quotation}

In other words: A new language in which object and signifier are similar or identical is believed to be superior to traditional symbolic language with its abstract object-sign relationships. While the paragraph reads like a straightforward critique of object-oriented graphical computer interfaces, this critique does not actually concern text as opposed to graphics, but grammatical versus ungrammatical language as communication interfaces. The objects cannot be linked, combined or condensed in a meaningful way to express more complex semantic operations. In the realm of computer operating systems, this translates into an opposition less of graphical versus textual, but of programmer-friendly versus programmer-hostile environments.

When Alan Kay developed the first graphical mouse-controlled computer environment at Xerox PARC in the 1970s, the separation between ``usage'' and ``programming'' was for the first time implemented as separation of media: ``Usage'' became graphical, ``programming'' textual. The gap widened with the commercialization of Kay's ideas through the Apple Macintosh and Microsoft Windows. While Alan Kay's user interface was based on the programming language Smalltalk and remained programmable in every of its aspects, to the point where users could create their own applications by combining pre-existing and self-written program objects,\footnote{A concept living on -- and currenlty being revived chiefly by artists working with the system -- in ``Squeak'', the latest incarnation of Kay's Smalltalk system, released a cross-platform Free/Open Source software}, the Apple Macintosh lacked the programming interface simply for economical and marketing reasons. Without Smalltalk, the system would run faster on low-power hardware, thus dropping sales prices and decreasing development costs. The result was a Swiftian ungrammatical operating system that gave birth to the ``user': You are supposed to read, not to write.\footnote{Which, by the way, doesn not apply only to propietary, but also to Free/Open Source graphical user interfaces like KDE and Gnome.} Only through this engineered gap, programming becomes a mystery, a black art, supposedly for the sake of making computing easier. Borrowing from Roland Barthes book ``S/Z'' from 1970, modern GUI operating systems could be called ``readerly'' while textual operating systems like Unix are ``writerly''. According to Barthes, the readerly text presents itself as linear, transparent, innocent; it ``attempts to conceal all traces of itself as a factory within which a particular social reality is produced through standard representations and dominant signifying practices.'' In contrast, the writerly text ``exhumes the cultural voices or codes responsible for the latter's enunciation and in the process it discovers multiplicity instead of consistency and signifying flux instead of stable meaning''.\footnote{\cite{barthes:sz-english}, p. 246}

Exactly this distinction shows why the question how ``our writing tools are also involved in writing our thoughts'', or how code shapes the aesthetics of the digital, is problematic in itself: precisely because it projects issues of pre-digital hardware onto digital software. Nietzsche's observation of the mechanical typewriter naturally assumes a clear-cut division, a material difference between the tool and the writing, the processor and the processed; a division however which no longer exists in computer software. Since computer software is tools made from writing, processors made from code, the material gap can only be sustained through simulation. To be readerly, popular PC user software creates the illusion of being hardware, visually and tactically diguising itself as solid analog tools. Graphic design software like Adobe Photoshop or Illustrator have palettes and pencils (as they are subverted in Adrian Ward's software artworks ``Autoshop'' and ``Auto-Illustrator''), web browsers pretend to be nautical navigation instruments (``Navigator'' and ``Explorer'' by Netscape and Microsoft), word processors like Microsoft Word are based on visual simulations of a piece of paper in a typewriter.\footnote{See also Matthew Fuller's cultural analysis of Microsoft Word in \cite{fuller:word}}

,,Multiplicity instead of consistency and signifying flux instead of stable meaning``: These attributes of the writerly exist on the Unix commandline as a hybridity of code. Since everything in Unix is text -- from the user programs which are executed as commands to the data flowing between the commands -- anything can be instantly turned into anything, writing into commands and command output into writing:

\begin{verbatim}

CORE CORE bash bash CORE bash

There are %d possibilities. Do you really wish to see them all? (y or n)

SECONDS SECONDS

grep hurt mm grep terr mm grep these mm grep eyes grep eyes mm grep hands mm grep terr mm > zz grep hurt mm >> zz grep nobody mm >> zz grep important mm >> zz grep terror mm > z grep hurt mm >> zz grep these mm >> zz grep sexy mm >> zz grep eyes mm >> zz grep terror mm > zz grep hurt mm >> zz grep these mm >> zz grep sexy mm >> zz grep eyes mm >> zz grep sexy mm >> zz grep hurt mm >> zz grep eyes mm grep hurt mm grep hands mm grep terr mm > zz grep these mm >> zz grep nobody mm >> zz prof!

if [ "x`tput kbs`" != "x" ]?; then # We can't do this with "dumb" terminal stty erase `tput kbs`

DYNAMIC LINKER BUG!!! \end{verbatim}

The above is an experimental codework by Alan Sondheim, generateed from interaction with a Unix-like textmode environment running ``bash'', the standard commandline interpreter of GNU/Linux operating systems. The medium of plain text allows to migrate all signifiers transparently from one symbolic form -- the operating system -- to a second one -- E-Mail -- all the while involving the third symbolic form of electronic word processing. The codes it contains are at English writing, system instruction code and Internet communication code simultaneously.

This conflation of codes is not an artistic invention of Sondheim, but a standard feature of the Unix operating system. The instantaneous convertibility of text as something processed (=data) and text as a processor (=program) that is characteristic of all program code is not suppressed in Unix by hiding the code away, but remains transparent on the level of user interaction. It is, as a matter of act, a system feature which Unix administrators rely on every day. Unix, and other operating systems which use written code not just as a hidden layer driving things underneath, but also as their user interface,\footnote{Other sophisticated examples being ITS, LISP machines, Plan 9, with DOS and 8-bit BASIC computers being primitive implementations of the concept} is a giant, modular and recursive text processing system which runs on script and parameters processed through themselves; or, as the programmer and system administrator Thomas Scoville puts it in his 1998 paper ``The Elements Of Style: UNIX As Literature'': ``UNIX system utilities are a sort of Lego construction set for word-smiths. Pipes and filters connect one utility to the next, text flows invisibly between. Working with a shell, awk/lex derivatives, or the utility set is literally a word dance.''\footnote{\cite{scoville:unix}}

While it is true for all software and all operating systems that the software tool itself is thus nothing but writing, the elegant simplicity of the Unix commandline relies on the idea programming, instead of being delegated to being a secluded application, becomes a trivial extension of ``using'' the system, simply by writing a sequence of commands into a text file and executing it, while operating systems working other than textual media haven't found a way yet to make data and processing interchangeable.

%%% CONTINUE HERE

The historical impact of this allegedly outdated, now revived mode of computing on digital art is Apart from that, Net.art has derived many of its forms from digital artisanship and hacker aesthetics developed in Unix and Mainframe terminal computing environments in the 1970s and 1980s:

\begin{itemize}

\item ASCII Art

\item code poetry (Perl poetry)

\item code language or slang

\item Malware or viral scripting, forkbombs

\item software art (self-referential programming jokes: recursion, Quines)

\item net culture and aesthetics (Jargon File, as mentioned by Tim Pritlove yesterday)

\end{itemize}

A common aspect of all these forms is that they reveal the subjective subtexts of formal systems. When, to quote Thomas Scoville again, the Unix vocabulary and syntax becomes ``second nature'', the formal language becomes a conversational and also artistic language: it is not only a tool involved in shaping thoughts, but a way of thinking itself, and thus a means of artistic subjectivity.

Codework: Code as diary (Alan Sondheim), code as manifesto (Netochka Nezvanova), code as a medium of reflection (mez): to express subjectivity through formal language becomes an artistic challenge and conceit.

\section{Codework}

The relationship between code and subjectivity can also be the other way round: Thinking of art in terms of software code, using programming as a metaphor. My last example is taken from an E-Mail work by the Australian artist and codeworker mez which relates to Perl (as it has been used in Ade Ward's and Alex McLean?'s slub presentation) which could be called an electicic condensation of Unix into a ``postmodern programming language'' (Larry Wall)\footnote{Or, to quote Thomas Scoville: ``In a literary light, if UNIX is the Great Novel, Perl is the Cliffs Notes.''}

\begin{verbatim} Choose||match. #!/bin/perl.

Choose a bloody obscure Code Poetry that transposes this hidden universe of language into something to read, instead of Computer

languages that are a product of the mind that often surpasses the abilities of the mind to decode.pl. Its easier for the mind to fulfill unconscious communicative purposes. By lightening tasks through encode.pl every bridge is like some other bridge that's been built. They can know the category for an automated process. What I do is take the output from encode.pl and put it into a file http://www.hotkey.net.au/~netwurker/txts and incorporate decode.pl into the program. Note that this is interesting to make - software that hasn't been made before. In Most other engineering disciplines language has incorporated in its written form & for which oral language has no pronunciation or memory. \end{verbatim}

Let me close my talk with Jonathan Swift again who did not only foresee the graphical user interface, but also the use of formal code as everyday language. He writes about the academics of the flying island of Lagado:

\begin{quotation} The knowledge I had in mathematics gave me great assistance in acquiring their phraseology, which depended much upon that science and music; and in the latter I was not unskilled. Their ideas are perpetually conversant in lines and figures. If they would, for example, praise the beauty of a woman, or any other animal, they describe it by rhombs, circles, parallelograms, ellipses, and other geometrical terms, or by words of art drawn from music, needless here to repeat. \end{quotation}

\end{document}