>> Christiane Paul, "CODeDOC II", 2003

from: http://www.aec.at/en/archives/festival_archive/festival_catalogs/festival_artikel.asp?iProjectID=12323


As part of the CODE exhibition accompanying this year’s festival, Ars Electronica invited me to curate a second installment of the online exhibition CODeDOC that I originally organized for the Whitney Museum of American Art’s artport, a website designed as a portal to netart. CODeDOC, which launched in September 2002, was conceived to explore the relationship between the underlying code of software art and its results. A dozen software artists were invited to code a specific assignment—“connect and move three points in space”—in a language of their choice (Java, C, Visual Basic, Lingo, Perl) and were asked to exchange the code with each other for comments. The presentation strategy of CODeDOC deliberately deviates from the ways in which viewers usually experience a piece of software art, which commonly presents itself to the audience as executed code—the results of written instructions. In CODeDOC, the viewing experience is closer to the artist’s creation process: what the audience encounters first is a page with the written code, from which they can launch its executed results. Since the assignment imposed substantial restrictions in format and file size, the contributed projects can’t necessarily be seen as fully developed works; rather, they are comparable to small studies and sketches that capture an artist’s approach.

Many of the prominent international practitioners in the field of software art could not participate in the first version of CODeDOC since the Whitney Museum is, by its mission, devoted to American artists (citizens and artists living and working in the US). CODeDOC presents a welcome opportunity to close that gap and widen the scope of the project. The eight artists/teams who were invited to contribute to the second installment and code the assignment—Ed Burton, epidemiC, Graham Harwood, Jaromil, Annja Krautgasser & Rainer Mandl, Joan Leandre, Antoine Schmitt and John F. Simon, Jr.—are mostly non-American. Some other artists who would have been obvious candidates for this project were not invited because they were already involved in other parts of the Ars Electronica Festival or exhibition. My special thanks go to Andreas Broeckmann for his input and suggestions in the selection process of the artists.

From its inception, CODeDOC was intended as a process-oriented experiment rather than an exhibition meant to make a specific statement or offer a certain point of view. Ideally, I wanted to raise questions about software art as artistic practice, and neither the outcome nor the reception of this project were easily predictable for me. One intent of the project certainly was to demystify the notion of code as a “mysterious,” hidden driving force and to reveal the code to the viewer. Among the questions that seemed important to address or clarify were the following: does the term software art itself describe a certain form of aesthetics? Do “signature,” “voice,” and aesthetics of an artist manifest themselves equally in the written code and its executed results? Will reading the source code enhance the perception of the work? Does it in fact add anything at all or just create an emphasis on “technicalities” that is unnecessary, alienating, and obscures the work? How exactly could one define the relationship between the back end of code and its results?

The attempt to provide detailed answers to all these questions would be beyond the scope of this introduction, and I just want to make some general comments and leave it up to the CODeDOC II projects themselves, as well as the discussions surrounding them, to offer further perspectives on these issues.

If one explores the body of work that each of the CODeDOC II participants has created over the years, it seems obvious that the label software art is a lowest common denominator for a formal description of their artistic practice rather than a term that describes specific aesthetics. The artists’ works themselves cover a broad spectrum of individual approaches. The works of epidemiC, for example—which include AntiMafia, a Windowsbased program for the co-ordination of associative actions, as well as the infamous biennale.py virus created for the 49th Venice Biennale (in collaboration with 0100101110101101.ORG)—are focused more on activism and the notion of software as cultural production. Ed Burton’s Sodaplay and Sodaconstructor, which in the meantime have achieved cult status, explore the conceptual possibilities of “handcrafted” virtual robots as well as masses and their kinetic energy. Grahame Harwood’s work has ranged from “pure” Perl poetry to software creation and narrative projects, such as the CD-ROM Rehearsal of Memory—which creates its interface out of a collage of the skins of the inmates and staff of Ashworth Hospital Authority—and the Web project Uncomfortable Proximity, commissioned by the Tate Museum, which reproduced the Tate website’s layout, logos, and design, to tell a “different” history of the British art system. Compared to the former examples, Antoine Schmitt's works are far more visually oriented studies of the “behaviours” of forms in time and space.

While one might assume that an artist's approach (and perhaps even “personality”) will manifest itself equally in the written code and its results, the code itself will naturally be more meaningful to other programmers than a general audience that might only get the roughest idea of its “mechanisms.” Whether the code adds to an understanding of the work also varies substantially from case to case. One might speculate that the emphasis that the artists themselves would put on the importance of their code partly depends on the nature of their respective work: for example, artists whose work focuses on “raw” code (such as many of Graham Harwood’s pieces) might consider the “written part” of the project more important than artists whose work is an exploration of visual forms, space, and action (such as many of Antoine Schmitt's projects). The presentation format of CODeDOC also seems to have imposed some (unintended) editing on the artists’ part: in their comments, both Antoine Schmitt (CODeDOC II) and Camille Utterback (CODeDOC I) admitted that they felt compelled to clean up their code before presenting it to the public (“I’m one of those people that clean my bathroom if my friends are coming over,” as Camille put it). One of the inherent dangers and certainly unintended effects of CODeDOC could be the misassumption that the quality of software art can be judged according to virtuosity and craftsmanship in the programming of code (that is, by criteria such as correctness, maintainability, lucidity, and readability, which were outlined by Donald Knuth). One of the beauties of art, no matter what form and material it takes, consists in the fact that its success is the result of multiple factors that cannot be objectively defined. A viewer could certainly enjoy the works of Leonardo da Vinci or Picasso on the basis of their outstanding virtuosity and craftsmanship alone (although they have much more to offer), but applying these standards to Duchamp’s urinal or Beuys’ “fat and felt” sculptures will presumably not yield relevant results or major appreciation. Like any other art form, software art cannot and should not be reduced to technical criteria, and the code should be seen as more than simply the wheels and gears driving the machine.

As an artistic medium and practice, software art seems to distinguish itself from other art forms such as painting, sculpture or film/video. As opposed to other forms of visual art, software artists write verbal instructions for their work that can be executed and produce anything from visuals to a more abstract communication process (although the execution of code still requires various steps of interpretation and compiling and the code itself may be mostly a notation of logic). There is a peculiar relationship between the mostly hidden backend of code—which constitutes a convergence of language and mathematics—and the multi-sensory “display” it can produce: an “identity” in the sense of a sameness in different instances (code results), each of which takes a very different form yet, on one level, is one and the same. While every art form may be processed and mediated in one way or another, it usually does not constitute a fusion of fundamentally different “materialities” (in the broadest sense) as software art does. A painting or sculpture to a large extent reveals the manifestations of its creation process in the finished object—for example, in individual brush strokes or materials—even if the art object amounts to something much larger than the sum of its parts. In software art, the “materiality” of the written instructions mostly remains hidden. In addition, these instructions and notations can be instantaneously activated; they contain and—further layers of processing aside—are the artwork itself. While one might claim that the same holds true for a work of conceptual art that consists of written instructions, this work would still have to be activated as a mental or physical event by the viewer and cannot instantaneously transform, transcend, and generate its own materiality.

In the comments accompanying his contribution to CODeDOC II, Antoine Schmitt points out that it would be a misleading shortcut to propose that the language in which a programmed artwork has been written has anything to do with the “language of programmed art”—a language relating to the space, time and action of the work. Schmitt makes an important point in that he hints at the multiple layers of “language” that a discourse about software art entails: there is the programming language itself (I assume that many programmers would argue that the choice of the programming language has a substantial effect on the outcome of the artwork); there is the language of the written code in the sense of an artistic expression that formulates instructions in an individual way (similar to the use of natural language that, despite a given vocabulary, grammar and rules, functions as a form of personal expression); and there is the aesthetic “language” of the code’s actions, comparable to the language of painting or cinema. At best, CODeDOC can raise some awareness surrounding both the construction and perception of software art, and I hope that the pieces created for this second round of the project will continue to contribute to an ongoing dialogue.

CODeDOC I:

http://artport.whitney.org/commissions/CODeDOC/

CODeDOC II:

http://www.aec.at/CODeDOCII

John F. Simon, Jr. (USA)
http://www.numeral.com

Annja Krautgasser / Rainer Mandl (A):
http://www.vidok.org
http://www.vidok.org

epidemiC (I):
http://epidemic.ws/

Joan Leandre (E)
http://www.retroyou.org/

Jaromil (A/I)
http://korova.dyne.org/

Ed Burton (UK)
http://soda.co.uk/

Antoine Schmitt (F)
http://www.gratin.org/as/

>> Olga Goriunova, Alexei Shulgin , "Artistic Software for Dummies and, by the way, Thoughts About the New World Order.", 2002

What is artistic software? Artistic software is, first and foremost, software created for purposes different than traditional pragmatic ones. Such programs are not seen as tools for the production and manipulation of digital objects - from online bank accounts to works of art - they are works of art in their own right. The emergence of this phenomenon is first of all due to the overall spread of software - commercial, proprietary programs as well as open source - and its introduction into all spheres of human activity. Software has always been seen as a neutral tool, tending to become a transparent medium for information processing, and a most comfortable one at that. Software and the products created with its help have always been considered not only to belong to totally different areas but even to be non-comparable. In most cases, an individual piece of software is thought to be completely interchangeable with a competing product without any effect on the result. Such an approach assumes several stereotypical and false premises. First, software is not a "transparent" tool for the creation and processing of the digital product. It defines a quite limited space, within a specific framework in which people are required to work. Thus it persistently forces people to keep to certain, pre-defined rules. In addition to the limitations of using computer programs there is also a certain predetermined position - a creative, social, even political one - into which the software user is put, not so much by the software's creators, but by more general power structures: the culture of software creation and media culture as a whole. And this, in turn, depends on the dominant social rules, which will be touched upon in this article. More and more people are finding these limitations not only uncomfortable but also boring and authoritarian. Second, the overall "digitalisation" of reality makes software, the basis of the functioning of digital space, increasingly important as such. Rationality and Western civilization The general and recently accelerating change in the world moves toward its deeper rationalisation. The forms, the methods of functioning of the society are all becoming extremely technologised. All means of functioning of the digital world - networks, software and even design are being created in accordance with notions of the rational basis of the universe and are the highest representation of the Western idea - the domination of the Reason. The history of Western civilization is, among other things, the history of human alienation, the history of rationalisation, the history of the loss of the mystical. The changes in the notion of Knowledge as the basis of progress can represent this history in the simplest terms. Up until the Middle Ages, knowledge was interwoven with magic, mysticism and religion. It was not considered, as it commonly is today, as something purely abstract which could nevertheless have practical applications. Knowledge could not be transmitted solely on the theoretical level, outside of ritual practice. It was transmitted only through personal and full communication of the chosen with the chosen. Even "crafts skills" knowledge could not have been acquired within just a couple of years. Knowledge was not detached from other forms of life. The situation starts to change during the Renaissance: gradually the theorisation of knowledge begins; knowledge separates itself from mysticism and religion and acquires high autonomous status. By the end of the XVII century the final break of knowledge from other forms of life is taking place. The history of rationalisation is the history of the diminishment of the leading role of religion, the history of exclusion of morality from all spheres except maybe that of the "life world" (Lebenswelt). Catholicism has introduced rationalised relations between man and God (indulgence); Protestantism has rejected ancient rituals and their traditional visual attributes and became the peak of the religious rationality, logically progressing to "humanistic" atheism. Gradually science took the place of religion. And science oriented itself towards the cognition of nature by defining nature in terms of matter's lack of inherent value and metaphysical attributes. Examining nature as an infinitely reusable object, science began to apply the same notions to the human being. Thus all scientifically unverifiable truths and meanings could neither be supported nor refuted by all-prevailing Reason. What now? - Science, having finally broken away from all its once inherent metaphysical goals, is becoming, by analogy with extreme sport, an extreme science, endangering the very existence of human beings on earth (nuclear and bio-technologies, overall penetration of technology and its use as a means of control over the human being). - The highly rational way of life in such societies as the US, can go out of whack from time to time: one of the most convincing examples lies in the events of the 11th of September 2001. The growing conflict between East and West - which can be seen as a conflict between an extremely rationalised western society and the metaphysically oriented eastern one - presents one of the most obvious dangers for the current world order. Culture as content The type of the society in which the citizens of "developed" countries are living has been called informational for a long time already. The system of such societies, accordingly, is utterly different from the preceding industrial one, which was centered around industrial production. Post-industrial society is ruled not by commodity-money relations but by informational currents. Or, rather currents of capital and power that are spreading (and to a large extent in the form of open or veiled propaganda) through networks, in accordance with new laws. All means and media by which such societies function - networks, computers, software and even design - are extremely technologised and are created in accordance with the notion of the rational basis of the universe. Culture and its manifestations are also turning into information (and even "content"), flowing into information space. Just like any other information, cultural information can be digitalised. With its shift into computer space, culture begins to function by the same rational rules according to which the rest of the system works - by the rules created, in particular, by designers and programmers. The methods of information presentation, storage and functioning, often define its content as well. In so far as there is no place for metaphysics within information space, the space towards which all spheres of public and personal life are moving, the mode of this space's being is particularly rational - culture as the custodian of the non-rational inevitably becomes sterilized in such space. Morality and "life world" - for a long time and very consistently too - have been being rationalised under the civilization processes. Within the digital environment this process yet intensifies. Existing in the digital realm, human beings are following its logic - the extra-ethical logic of the machine. Art as the custodian of the non-rational Art is one of the most mobile and diverse systems; it has been changing continuously to the extent that it contradicts itself. It would be interesting, then, to look at the change in the artist's social role: - Ancient times. There is no artist yet as such - she is an ordinary member of the society, additionally performing some religious functions. Her work is based exclusively on tradition, her name is not announced, the results of her work are part of the mystical ritual. - The epoch of Renaissance and Humanism: the artist is breaking from the religious tradition and begins to glorify the beauty of the human and of the surrounding world. The figure of the self-manifesting Genius appears on stage. - The Technological epoch: The beauty of the world becomes easily reflectable through technical reproduction media. At the same time the ideals of humanism decline - as a consequence of technological progress as well. On one hand, art begins to reflect the crisis of human self-consciousness (modernism), and on the other, it gets diverted into a certain form of commercial activity. Works of art turn into commodities, an extensive art-market is created (there appears, in particular, a notion of "the original"). During the preceding, humanistic epoch, the artist was placed very high in society (artist: demiurge, poet: the ruler of people's minds). Therefore, on the new technological level she begins to actively participate (and be used) in the political struggle. The Communication epoch With the development and fundamental change of communicative space the role of the artist is changing again. Artist is not someone who creates images anymore; she rejects the idea of representation. Information overload becomes a common illness. An infinite number of images have already been created; they are kept in unerasable digital form in readily accessible databases. On the whole, the existing culture can already be represented as information currents that surround people and constantly try to penetrate their minds. The artist's mission now shifts from creating images to manipulating and redirecting information currents. The artist becomes, on one hand, the information filter, and on the other, its re-transmitter. This new role of the artist, then, in many ways becomes linked with the functions of communication and computer technologies: her activity is performed by means of networks and computers. The difference is that computers work on the basis of "bare" algorithms, while humans apply intuition, emotions and other non-rational elements - exactly those qualities that are beginning to disappear due to the influence of technology that makes everyone work rationally. Thus design of networks, databases, computers and software becomes defining factor in modern culture. Software and computers tend to be seen exclusively as pragmatic tools for information processing; programmers are usually exceptionally pragmatic people whose rational side often prevails over all others. Therefore, the artist has to confront pragmatism with the methods she is well acquainted with, based on intuition and non-rationality. Thus, artistic software appears. How does software art save non-rationality? One might ask, "How can software art be non-rational, if rational algorithms are what lies at its basis?" Yes, at the basis of each piece of software there are definite algorithms, but if conventional programs are instruments serving purely pragmatic purposes, the result of the work of artistic programs often finds itself outside of the pragmatic and the rational. Because the process of the digitalisation of culture and other components of social life is inevitable, it is necessary to consider adequate ideas and mechanisms for the transfer of those spheres into digital space, to find adequate conditions for their functioning within networks. How can we put forth such mechanisms, those which would preserve the remaining grains of the non-rational and metaphysical, those which could guarantee the safety of the society and protect it against further rationalisation? Artistic software, non-rational software, perhaps gives some answers to this question. Appendix. Most common characteristics of artistic software: - irony 18% - addressing political and social issues 10% - interface prevailing over functionality 20% - deconstruction 16% - non-rationality 25% - other 11% (data for the beginning of 2002)

>> runme.org

about:
Runme.org is a software art repository, launched in January 2003. It is an open, moderated database to which people are welcome to submit projects they consider to be interesting examples of software art.

Software art is an intersection of two almost non-overlapping realms: software and art. It has a different meaning and aura in each. Software art gets its lifeblood and its techniques from living software culture and represents approaches and strategies similar to those used in the art world.
Software culture lives on the Internet and is often presented through special sites called software repositories. Art is traditionally presented in festivals and exhibitions.

Software art on the one hand brings software culture into the art field, but on the other hand it extends art beyond institutions.

The aim of Runme.org is to create an exchange interface for artists and programmers which will work towards a contextualization of this new form of cultural activity. Runme.org welcomes projects regardless of the date and context of their creation. The repository is happy to host different kinds of projects - ranging from found, anonymous software art to famous projects by established artists and programmers.

Runme.org is structured in two major ways: taxonomically/rationally (category list) and intuitively (keyword cloud).
The best works submitted to Runme.org will be reviewed by the "experts", who will change over time.

Though Runme.org partly grew from the Read_me 1.2 festival, it is an autonomous repository upon which the festival is now based.
The second edition of Read_Me festival took place in Helsinki in May 2003.

Runme.org is a collaborative and open project that was developed by Amy Alexander, Florian Cramer, Matthew Fuller, Olga Goriunova, Thomax Kaulmann, Alex McLean, Pit Schultz, Alexei Shulgin, and The Yes Men. In summer 2003 Hans Bernhard and Alessandro Ludovico have joined the expert team.

Runme.org website is conceptualized and administrated by Amy Alexander, Olga Goriunova, Alex McLean and Alexei Shulgin. It is developed by Alex McLean.

Special thanks to: NIFCA, Lume and m-cult.
Runme.org is hosted by m-cult.

Other credits:
- Keyword browsing idea - Damian
- Trigonometry - Signwave

>> Florian Cramer + Ulrike Gabriel, "Software Art", 2001

from: http://www.netzliteratur.net/cramer/software_art_-_transmediale.html

What is software art? How can "software'' be generally defined? We had to answer these questions at least provisionally when we were asked to be with the artist-programmer John Simon jr. in the jury of the "artistic software'' award for the transmediale.01 art festival in Berlin, Germany.

Since more than a decade, festivals, awards, exhibitions and publications exist for various forms of computer art: computer music, computer graphics, electronic literature, Net Art and computer-controlled interactive installations, to name only a few, each of them with its own institutions and discourse. Classifications like the above show that attention is usually being paid to how, i.e. in which medium, digital artworks present themselves to the audience, externally. They also show that digital art is traditionally considered to be a part of "[new] media art,'' a term which covers analog and digital media alike and is historically rooted in video art. But isn't it a false assumption that digital art - i.e. art that consists of zeros and ones - was derived from video art, only because computer data is conventionally visualized on screens?

By calling digital art "[new] media art,'' public perception has focused the zeros and ones as formatted into particular visual, acoustic and tactile media, rather than structures of programming. This view is reinforced by the fact that the algorithms employed to generate and manipulate computer music, computer graphics, digital text are frequently if not in most cases invisible, unknown to the audience and the artist alike. While the history of computer art still is short, it is rich with works whose programming resides in black boxes or is considered to be just a preparatory behind-the-scenes process for a finished (and finite) work on CD, in a book, in the Internet or in a "realtime interactive'' environment. The distribution of John Cage's algorithmically generated sound play "Roarotorio,'' for example, includes a book, a CD and excerpts of the score, but not even a fragment of the computer program which was employed to compute the score.

While software, i.e. algorithmic programming code, is inevitably at work in all art that is digitally produced and reproduced, it has a long history of being overlooked as artistic material and as a factor in the concept and aesthetics of a work. This history runs parallel to the evolution of computing from systems that could only be used by programmers to systems like the Macintosh and Windows which, by their graphical user interface, camouflaged the mere fact that they are running on program code, in their operation as well as in their aesthetics. Despite this history, we were surprised that the 2001 transmediale award for software art was not only the first of its kind at this particular art festival, but as it seems the first of its kind at all.

When the London-based digital arts project I/O/D released an experimental World Wide Web browser, the Web Stalker http://www.backspace.org/iod/, in 1997, the work was perceived to be a piece of Net Art. Instead of rendering Web sites as smoothly formatted pages, the Web Stalker displayed their internal control codes and visualized their link structure. By making the Web unreadable in conventional terms, the program made it readable in its underlying code. It made its users aware that digital signs are structural hybrids of internal code and an external display that arbitrarily depends on algorithmic formatting. What's more, these displays are generated by other code: The code of the Web Stalker may dismantle the code of the Web, but does so by formatting it into just another display, a display which just pretends to "be'' the code itself. The Web Stalker can be read as a piece of Net Art which critically examines its medium. But it's also a reflection of how reality is shaped by software, by the way code processes code. If complex systems and their generative processors themselves become language, formulation becomes the creation of a frame within which the system will behave, and of the control of this behaviour. The joint operation of these processes creates its own aesthetics which manifests itself no longer by application-restricted assignments, but in the free composition of this system as a whole. (Which simply is what developing software is all about.)

Since software is machine control code, it follows that digital media are, literally, written. Electronic literature therefore is not simply text, or hybrids of text and other media, circulating in computer networks. If "literature'' can be defined as something that is made up by letters, the program code, software protocols and file formats of computer networks constitute a literature whose underlying alphabet is zeros and ones. By running code on itself, this code gets constantly transformed into higher-level, human-readable alphabets of alphanumeric letters, graphic pixels and other signifiers. These signifiers flow forth and back from one aggregation and format to another. Computer programs are written in a highly elaborate syntax of multiple, mutually interdependent layers of code. This writing does not only rely on computer systems as transport media, but actively manipulates them when it is machine instructions. The difference is obvious when comparing a conventional E-Mail message with an E-Mail virus: Although both are short pieces of text whose alphabets are the same, the virus contains machine control syntax, code that interferes with the (coded) system it gets sent to.

Software art means a shift of the artist's view from displays to the creation of systems and processes themselves; this is not covered by the concept of "media.'' "Multimedia'', as an umbrella term for formatting and displaying data, doesn't imply by definition that the data is digital and that the formatting is algorithmic. Nevertheless, the "Web Stalker'' shows that multimedia and terms like Net Art on the one hand and software art on the other are by no means exclusive categories. They could be seen as different perspectives, the one focussing distribution and display, the other one the systemics.

But is generative code exclusive to computer programming? The question has been answered by mathematics proper and the many historical employments of algorithmic structures in the arts. A comparatively recent classical example is the Composition 1961 No. I, January I by the contemporary composer and former Fluxus artist La Monte Young, which is at once considered to be one of the first pieces of minimal music and one of the first Fluxus performance scores:

"Draw a straight line and follow it.''¹

This piece can be called a seminal piece of software art because its instruction is formal. At the same time, it is extremist in its aesthetic consequence, in the implication of infinite space and time to be traversed. Unlike in most notational music and written theatre plays, its score is not aesthetically detached from its performance. The line to be drawn could be even considered a second-layer instruction for the act of following it. But as it is practically impossible to perform the score physically, it becomes meta-physical, conceptual, epistemological. As such the piece could serve as a paradigm for Henry Flynt's 1961 definition of Concept Art as "art of which the material is `concepts,' as the material of for ex. music is sound.''² Tracing concept art to artistic formalisms like twelve-tone music, Flynt argues that the structure or concept of those artworks is, taken for itself, aesthetically more interesting than the product of their physical execution. In analogy, we would like to define software art as art of which the material is software.

Flynt's Concept Art integrates mathematics as well, on the acognitive grounds of "de-emphasiz[ing]'' its attribution to scientific discovery.³ With this claim, Flynt coincides, if oddly, with the most influential contemporary computer scientist, Donald E. Knuth. Knuth considers the applied mathematics of programming an art; his famous compendium of algorithms is duely titled "The Art of Computer Programming.''⁴

Should the transmediale software art jury therefore have consisted of mathematicians and computer scientists who would have judged the entries by the beauty of their code?

What is known as Concept Art today is less rigorous in its immaterialism than the art Flynt had in mind. It is noteworthy, however, that the first major exhibition of this kind of conceptual art was named "Software'' and confronted art objects actually with computer software installations.⁵. Curated in 1970 by the art critic and systems theorist Jack Burnham at the New York Jewish Museum, the show was, as Edward A. Shanken suggests, "predicated on the idea of software as a metaphor for art [my emphasis],''⁶. It therefore stressed the cybernetical, social dimension of programmed systems rather than, as Flynt, pure structure.

Thirty years later, after personal computing became ubiquituous, cultural stereotypes of what software is have solidified. Although the expectation that software is, unlike other writing, not an aesthetic, but a "functional tool'' itself is an aesthetic expectation, software art nevertheless has become less likely to emerge as conceptualist clean-room constructs than reacting to these stereotypes. The "Web Stalker'' again might be referred to as such a piece. In a similar fashion, the two works picked for the transmediale award, Adrian Ward's "Signwave Auto-Illustrator'' and Netochka Nezvanova's "Nebula M.81,'' are PC user software which acts up against its conventional codification, either by mapping internal functions against their corresponding signifiers on the user interface (Auto-Illustrator) or by mapping the signifiers of program output against human readability (Nebula M.81).

The range of works entered for the transmediale.01 software art award shows that coding is a highly personal activity. 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. Such attributes might seem to contradict the fact that artistic control over generative iterations of machine code is limited, whether or not the code was self-written. But unlike the Cagean artists of the 1960s, the software artists we reviewed seem to conceive of generative systems not as negation of intentionality, but as balancing of randomness and control. Program code thus becomes a material with which artist work self-consciously. Far from being simply art for machines, software art is highly concerned with artistic subjectivity and its reflection and extension into generative systems.⁷

References

[Fly61]

Henry Flynt. Concept art. In La Monte Young and Jackson MacLow, editors, An Anthology. Young and MacLow, New York, 1963 (1961).

[hun90]

George Maciunas und Fluxus-Editionen, 1990.

[Knu98]

Donald E. Knuth. The Art of Computer Programming. Addison-Wesley, Reading, Massachusetts, 1973-1998.

[Sha]

Edward A. Shanken. The house that jack built: Jack burnham's concept of `software` as a metaphor of art. Leonardo Electronic Almanach, 6(10). http://www.duke.edu/~giftwrap/House.html.

Footnotes:

¹facsimile reprint included in [hun90], no page numbering

²Henry Flynt, Concept Art [Fly61] "Since `concepts' are closely bound up with language,'' Flynt writes, "concept art is a kind of art of which the material is language.''

³ibid.

⁴[Knu98]

⁵Among them Ted Nelson's hypertext system in its first public display, according to Edward A. Shanken, The House that Jack Built: Jack Burnham's Concept of "Software'' as a Metaphor for Art, [Sha]

⁶ibid.

⁷Or, as Adrian Ward puts it: "I would rather suggest we should be thinking about embedding our own creative subjectivity into automated systems, rather than naively trying to get a robot to have its `own' creative agenda. A lot of us do this day in, day out. We call it programming.'' (quoted from an E-Mail message to the "Rhizome'' mailing list, May 7, 2001)

>> Florian Cramer, "words made flesh: code, culture, imagination", 2005

"ABSTRACT: Executable code existed centuries before the invention of the computer in magic, Kabbalah, musical composition and experimental poetry. These practices are often neglected as a historical pretext of contemporary software culture and electronic arts. Above all, they link computations to a vast speculative imagination that encompasses art, language, technology, philosophy and religion. These speculations in turn inscribe themselves into the technology. Since
even the most simple formalism requires symbols with which it can be expressed, and symbols have cultural connotations, any code is loaded with meaning. This booklet writes a small cultural history of imaginative computation, reconstructing both the obsessive persistence and contradictory mutations of the phantasm that symbols turn physical, and words are made flesh."

the whole book can be downloaded as a pdf from:
http://pzwart.wdka.hro.nl/mdr/research/fcramer/wordsmadeflesh/wordsmadefleshpdf

>> Florian Cramer, mez, ,,Re(ad.htm" , 2002

from: http://cramer.plaintext.cc:70/all/mez/mez-presentation.html


mez is the self-chosen shorthand of the Austrial net artist Mary Anne Breeze. Since its beginning, Net.art organized itself around international mailinglists such as Nettime and Rhizome. But many net artists didn´t use mailinglists just to communicate about net art, but as a net.artistic medium themselves. A popular tactics was to intentionally spam mailinglists with seemingly unreadable clusters of letter and number codes.

Mez comes from this tradition. Her entry "Re(ad.htm´´ is a selection of her mailinglist postings. As an example, I pick the first half of the piece "_Viro.Logic Condition][ing][ 1.1_´´:

_Viro.Logic Condition][ing][ 1.1_

[b:g:in]

::Art.hro][botic][scopic N.][in][ten][dos][tions::
1.[b.ranch outwards||seething
jam-jar curs][ed][ored
drenching s][creening][ounds]

::Neol][o.jism][ithic Rever][b][s.al][l][s::
2.[drink sever][al][ed
c u in he][l][avan
a c][yclops][hair b:cumming sane]

::Gig:a][h!][:cycling::
3.[alert & c.rash.ing
chrysa][s][li][ding!][s//via
code syrup & brooding symbols]

What seems like an unreadable mess at first, turns out to be subtle and dense if you read closer. The whole text borrows from conventions of programming languages; it presents itself as a program with a title, version number, main routine - indicated with the line "[b:g:in]´´ - and several subroutines or objects (which, like in the programming language Perl, are indicated with two double colons). But the main device are the square brackets which, like in Boolean search expressions, denote that a text can be read in multiple ways. For example, the title reads simultaneously as "Virologic Condition´´, "Virologic Conditioning´´, "Logic Condition´´ and "Logic Conditioning´´. This technique reminds of the portmanteau words of Lewis Carroll and James Joyce's "Finnegans Wake´´, but is reinvented here in the context of net culture and computer programming.

As the four readings of the title tell already, this particular text is about humans and machines and about a sickness condition of both. The square bracket technique is used to keep the attributions ambiguous. For example, the two words in the line

"::Art.hro][botic][scopic N.][in][ten][dos][tions::´´

can be read as "arthroscopic´´ / "art robotic´´ / "Arthrobotic´´ / "horoscopic´´ and "Nintendos´´ / "intentions´´ or "DOS´´. So the machine becomes arthritic, sick with human desease, and the human body becomes infected with a computer virus; in the end, they recover by "code syrup & brooding symbols´´.

So mez has taken ASCII Art, as we can see it in the exhibition above, and Net.art code spamming and refined it from pure visual patterns into a rich semantical private language. She calls it mezangelle which itself is a mez hybrid for her own name and the word "to mangle´´.

But why did we accept and shortlist the piece as software art? In the jury, we defined software art as algorithmic code and/or reflections of cultural concepts of software. In my opinion, mez´ work fits both parts of the definition. Since her square-bracketted expressions expand into multiple meanings, they are executable, that is, a combinatory sourcecode which generates output. But it's also a sophisticated reflection of cultural concepts of software which rereads the coding convetions of computer programming languages as semantical language charged with gendered politics. It's imaginary software which executes in the minds of computer-literate human readers, not unlike the Turing Machine which was an imaginary piece of hardware.

So one could put mez' work as well into the context of code poetry, like the many poetry written in the programming language Perl in the early 1990s, which to the largest extent was also pseudo-code that didn't actually execute on a machine. But while most of this classical code poetry was kitschy haikus and highschool love poetry, mez succeeds in rewriting code poetry into contemporary art in the best sense of the word.

>> Florian Cramer, "Exe.cut[up]able statements: The Insistence of Code", 2003

from: http://www.aec.at/en/archives/festival_archive/festival_catalogs/festival_artikel.asp?iProjectID=12319
for ciation please also go to this site

THE RESURGENCE OF CODE

Friedrich Nietzsche’s aphorism that “our writing tools are also involved in our thoughts,” put down after he first used a mechanical typewriter, has become an axiom of contemporary media theory. Applied to computer code and art, it could also be phrased as 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 Dutch/Belgian artists Jodi in Malmö/Sweden, June 2003, can be read beyond its specific description of the work exhibited as a programmatic statement that leads 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. It dismantles the notion 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 was first sold. While artists had 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. (1) 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 is “Codeworks”, (2) chiefly E-Mail-based Net.art written in private languages which hybridize English, program and network code and visual typography, like the following:

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.

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-describing executable sourcecode which expands, among other things, into “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 the E-Mail codeworks of Alan Sondheim, Jodi, Graham Harwood, 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 so-called 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; (3) 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. One is Free (or Open Source) Software, as it has gained the attention of a larger public since circa 1998; the other one is software art, a topic in the digital arts since circa 2000. Both discourses intersect 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.

FROM UTOPIA TO USER COMPUTING

Investigating the insistence of code in computer-based art and technology is pointless, 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 circuitry, for example, (4) or simply as a chain of zeros and ones. The problem not only concerns media in particular, but linguistics and semiotics in general: How can language in its complexity, cultural particularity and oddity be boiled down to an easy-to-grasp international system?

The question is much older than computer interface research, having been addressed in such works as 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, all knowledge is conveyed to the public via a graphical user interface:

It is 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. (5)

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 pictorial languages, and the dilemma of linguistic operations through graphical user interfaces were still being addressed in 1706 in the “Grand Academy of Lagado” chapter of Jonathan Swift’s “Gulliver’s Travels”:

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. (6)

In other words, a new language in which object and sign 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 iconic graphical computer interfaces, this critique does not actually concern text as opposed to graphics, but grammatical versus ungrammatical language as a means of communication. 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 programmerhostile 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 fully programmable to the point where users could create their own applications by combining pre-existing and self-written program objects, (7) the Apple Macintosh lacked the programming interface simply for economical and marketing reasons. Without Smalltalk, the system could run fast on low-power hardware, thus dropping sales prices and decreasing development costs. The result was an ungrammatical Swiftian operating system that gave birth to the “user”, with the message: You are supposed to read, not to write. (8) 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” and command line-centric operating systems lioke Unix “writerly”. According to Barthes, the readerly text presents itself as linear and smoothly composed, “like a “cupboard where meanings are shelved, stacked, safeguarded.” (9) Reflecting in contrast the “plurality of entrances, the opening of networks, the infinity of languages,” (10) the writerly text aims to make “make the reader no longer a consumer, but a producer of the text.” (11)

WRITERLY COMPUTING

Barthes’ distinction shows why the question how “our writing tools are also involved in 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. This division, however, no longer exists in software since computers adopted the von Neumann architecture of storing both instruction code and data in the same physical and symbolic realm. 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 disguising itself as solid analog tools. (12) Graphic design software like Adobe Photoshop or Illustrator have palettes and pencils (which 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. (13)

The attributes of the “writerly” on the other hand exist on the Unix commandline as a hybridity of codes. Since almost everything in Unix is ASCII text—from the user programs which are executed as Word commands and its feedback message to the data flowing between the commands—anything can be instantly turned into anything, writing into commands and command output into writing:

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!!!

The above is an experimental codework by Alan Sondheim, generated 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 all signifiers to migrate 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 English writing, system instruction code and Internet communication code simultaneously.

This conflation of codes is not a particular artistic invention of Sondheim, but a standard feature of the Unix operating system. The instantaneous mutual convertibility of text as something processed (i.e. data) and text as a processor (i.e. programs) that is characteristic of all program code is not suppressed in Unix by hiding the code away, but transparently preserved on the level of the user interface. 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, (14) is a giant, modular and recursive text processing system which runs on scripts 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 wordsmiths. 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.” (15)

While it is true for all software and all operating systems that the software tool itself is nothing but writing, the elegant simplicity of the Unix commandline relies on the idea that programming, instead of becoming a secluded application, is a trivial extension of “using” the system, simply by writing a sequence of commands into a text file which then can be executed. By contrast, operating systems working in other than textual media contrast haven’t found a way yet to make data and processing interchangeable and extend graphical user interfaces to graphical programming interfaces. Even Alan Kay concedes that “it would not be surprising if the visual system were less able in this area [of programmation] than the mechanisms that solve noun phrases for natural language. Although it is not fair to say that ‘iconic languages can’t work’ just because no one has been able to design a good one, it is likely that the above explanation is close to truth”—a truth explaining why alphanumeric text remains the most versatile notation system for computer instructions. (16)

IMAGINARY COMPUTING

If a medium is defined as something in between a sender and a receiver, i.e. a transmission channel or storage device, then computers are not just media, but also senders and receivers which themselves are capable of writing and reading, generating, filtering and interpreting messages within the limitations of the formal rule sets inscribed into them. (17)

Alan Kay’s outcry “the computer is a medium!” (18) explains why his system fails to provide more than a rudimentary grammar and a fixed set of abstractions—as opposed to the Turing complete grammar and programmable abstractions of, for example, Unix shells—, encompassing only prefabricated algorithmic processors (“user programs”) and storage and transmission operations like “open”, “save”, “close”, “send”, “cut”, “copy”, “paste”.

Not surprisingly, art forms which reflect the computer beyond its functioning as a medium were coined as artisanship by programmers in textual notation: programming language poetry (like Perl poetry), code slang (generated by manipulation text with algorithmic filters), viral scripting, in-code recursions and ironies (as, for example in the self-replicating sourcecode of “Quines”), all of them being largely independent of particular transmission and storage media or output technology—including computer screens, voice output, print books and t-shirts alike—and all of them having been systematically appropriated in the experimental digital arts since the late 1990s. The hacker “Jargon File”, (19) whose first versions appeared around 1981 at the MIT, is therefore to be read not only as the poetics of these forms, but also as a blueprint for net culture and net art since the mid-1990s. When, as Thomas Scoville writes, instruction vocabulary and syntax like that of Unix becomes “second nature”, (20) it follows that formal turns into conversational language, and syntax into semantics. Beyond being a “tool” merely “involved” in shaping thoughts, computer language becomes a way of thinking and mode of subjectivity, making even such code exe.cut[up]able which can only run in the reader’s imagination. (21)

(Thanks to Saul Albert, Josephine Bosma, Frederic Madre and Robbin Murphy for comments and critique)



The full book is on Florian Cramer's website:
http://cramer.plaintext.cc:70/all/executable_statements/executable_statements.pdf