>> Roman Verostko, "Epigenetic Art Revisited: Software as Genotype", 2003

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

Roman Verostko’s 1988 paper on “Epigenetic art: software as genotype” was published in Leonardo in 1990. For the 1993 Ars Electronica exhibition catalogue, Genetic Art / Artificial Life, he summarized the substance of the paper as “Notes on epigenetic art”. Here, tempered with 20 years’ experience as an algorist and 40 years as an artist, he revisits his original views on coded artistic procedures.

The beginnings.

For over 40 years, as an artist, I have sought to create works pointing to hidden or unseen reality. Early on I learned to wonder about the marvelous event of things existing “just the way they are” and whether there could be other ways “to be”. Within commonplace phenomena I learned to see a marvelous world filled with mystery. My approach to art grew from this sense of wonder about most things and a reverence for the materials of earth. Eventually this wonder came to include circuit boards, computer languages, and the art forms one could explore with simple algorithms.

Terminology.

Talking about code, algorithms, or algorists can evoke wrinkled foreheads and blank stares. Let me offer some clarification. An algorithm can be viewed as a detailed step-by-step procedure for carrying out a task. A recipe for baking bread or directions for reaching a specific location can be viewed as algorithms.

Clearly most kinds of instructions are not written to create art. “But,” we may ask, “Can we write instructions for creating art?” “Can an artist ‘code’ a work of art?” Emphatically, “Yes!”

In responding I will use terms like “mind-ear” and “mind-hand” to indicate that the process of writing instructions for making art engages the whole person and cannot be identified with one body part separated from another. Consider Chopin’s score for his Nocturne opus 27. Chopin created the musical notation or code that instructs the performer on how to play the Nocturne. The score, a unique procedure, provides detailed instruction for playing a specific musical form. It literally embodies a musical idea that originated in Chopin’s “mind-ear” in 1835. His mind “conceiving sound” embodies his sense of hearing. When hearing a performance today we assume that Chopin’s musical idea, as he conceived hearing it, has reached us via the musical score—an instruction, an algorithm. Inasmuch as Chopin’s musical idea is adequately represented in the score, and, inasmuch as the performer interprets the score as Chopin intended, then we enjoy an experience of Chopin’s “mind-ear”.

The contribution of the performer surely colors each performance in a unique way and is not taken lightly. Even so, the musical score transcends an individual performance and continues to have a meaningful existence over generations. Note that the “musical score” is written in a “code” consisting of symbols specifying time and qualities of sound. In general, when we use the term “code”, we are referring to an instruction or algorithm in its notational form, a specialized language for precisely representing the instruction. Well formed code displays splendid rationality with every detail clearly spelled out. Note, however, that the procedure for creating the code transcends our understanding. We can study Chopin’s nocturne and understand every detail of the score: but we cannot fathom the procedure by which Chopin created the score. We must be careful not to confuse the procedure by which the artist creates the code with the procedure specified in the code. The creative process lies primarily in the process of writing the code.

Coded visual form.

With these considerations in mind let us turn our attention from coded “musical form” to coded “visual form”. I am a founding member of an informal group of artists known as algorists. (1) For us, the term algorist applies broadly to any artist who employs original coded procedures for generating art forms. My interest, shared with pen plotter algorists, focuses on coded drawing procedures.

An algorist’s envisioned drawing procedure should not be thought of as a disembodied concept conceived apart from a feeling hand. Just as a composer composes with his “mind-ear” so an algorist composes with his “mind hand”. As surely as the mind is present to the hand when it draws, so also the hand is present to the mind when it creates drawing procedures.

To achieve this, an algorist, in writing code, addresses aesthetic qualities and limits of media and machine, for example, how paper surface and sizing affect the receptivity of ink. An algorist translates sensibility to these factors into intelligent coded operations. Specifically how does one get from this “mind-hand” drawing as “code” to the actual drawing? In my case, the code, operating on a PC, instructs a drawing machine known as a multi-pen plotter. These machines, designed for engineers and architects, have “drawing arms” that can select from a bank of pens and draw lines precisely as instructed. In 1987 I adapted paintbrushes to fit the drawing arm and have written special procedures for executing brush strokes. For the most part my works employ thousands of pen strokes with only occasional use of brush strokes.

The drawing arm and recursion.

One is tempted to view the plotter’s drawing-arm as a simulator of the artist’s physical hand. This is not the case. Rather it executes the “mind-hand” of the artist. The algorist’s “mind-hand” embodies precision with extensive drawing procedures that exceed the reach of a physical drawing hand. We could say the artist’s mind-hand draws via the machine’s drawing-arm something like the power shovel operator’s hand shovels with the power shovel’s shovel.

These abilities can be original drawing manoeuvres that exceed the capacity and dexterity of the human hand because they employ functions capable of unlimited iteration while improvising on themselves. The mind-hand can conceive of a drawing loop that looks back at what has been drawn and sets a procedure for improvising on the next drawing movement. The artist can create procedures for improvising upon improvised moves for each step along the way. This kind of “drawing-mind” engages the deep well of recursive procedure. Through experience the algorist learns how to set improvisational rules to achieve aesthetic preferences.

Recursive procedures are not new. The expression for the Fibonacci number series would be a simple recursive function, [n+(n+1)=n+2]. What is new is the ability to execute code for extensive recursive iteration yielding dimensions of improvisation in drawing that exceed what our minds can contain or what our hands can draw. This capability would have been, to my mind, a heavenly delight in the hands of artists like Wassily Kandinsky, Piet Mondrian and the Pevsner brothers. Recursion lies at the very heart of algorist art. This is how self-similar qualities of the drawing lines and brush strokes in my Epigenesis mural become imbedded in drifting pen stroke clusters that mirror each other. (2) Herein lies the unique feature of computing power coupled with an artist’s coded procedure.

Studio practice on the new frontier.

For over a quarter century I have marveled at the power of coded procedure for experimenting with visual form. Artists who have integrated their art with original coded procedures are on the threshold of a new frontier. In tapping this frontier they are confronted with two great hurdles. One has been the task of translating form-generating ideas into a practical working code. The other has been the search for appropriate methods for producing the work in a tangible form.

The code as a form generating idea is only half the struggle. To succeed as art, the code must be able to generate tangible form—something one can see, touch, feel or hear. Some years ago an artist friend, standing by an elm tree, asked, “What gives this tree such a powerful presence?” And he answered, “You can touch it—feel its surface—its ‘being here’!” Because aesthetic experience involves the senses, one cannot separate art from its material embodiment. In addressing human sensibilities artists embrace many diverse media including those emerging in cyberspace culture. My commitment has been clearly bent towards creating drawings and paintings on paper. My procedures are attentive to aesthetic qualities of papers, inks, pens, brushes and the manner of presentation. For me, the finished work should have an aura that invites the casual viewer to pause for a moment, sensing that the work, as a human endeavor, goes beyond material concerns.

Even so, the process holds an unusual fascination in and of itself.

Studio Scribes.

Many people who visit my studio are surprised when they see several engineering plotters cabled to a network of computers, one reserved for my experimental work and the others for generating art. When a plotter is working, visitors often stand with eyes glued on the drawing arm which, with a "seeming intelligence", draws precisely, surprisingly, and without hesitation—executing literally thousands of lines, and exuding an uncanny presence!

My first pen plotters, with names like Brunelleschi and Alberti, are now retired. Occasionally I bring Brunelleschi out of storage and have him make a small drawing. Although maintaining register is difficult and the movements are a bit coarse he can still execute a drawing to my approval. Over the years I have come to view my studio as a scriptorium with a network of electronic scribes. These scribes execute instructions tirelessly. Occasionally a specific work may require several days of drawing. Large pieces remain very difficult to achieve because of pen or hardware failure.

One can write code for unlimited sequences and a vast array of forms, but the drawing process must be coded in terms of specific drawing materials and tools. The code specifies procedures that operate with these tools in real time and space. The actual procedure must mesh with the limits and aesthetic qualities of paper and drawing instruments. At its best the code optimises the operation of tools and amplifies the aesthetic qualities of paper, ink and the character of the marking instrument.

Coping with these technological limits requires patience and experience with endless hours of trial and error. The jewel in this quest is the piece of code that works—like the acorn that can grow into a tree, the successful code literally “grows” a work of art! This procedure for making art remains essentially the same today as in the 1980’s when I wrote the original paper “Epigenetic Painting: Software as Genotype”. (3)

A Personal System.

The software, with a computer and a plotter, constitutes a complete personal system. Experimentation with paper, inks and plotting procedures has been extensive. Through many years of trial and error the system has evolved into a unique set of procedures with a language of its own. The software, under ongoing development, is an integrated program of algorithms written in elementary BASIC with plotter commands in DMPL. Routines have grown to thousands of lines.

RAD(SID)=(INT(RND*(RMAX-RMIN))+RMIN)
THETA(SID)=INT(RND*(DEGEND-DEGBEG))+DEGBEG
XQ=X1:YQ=Y1
JX(SID)=X1+INT((RAD(SID)*STRETCH)*COS(THETA(SID)*(PI/180)))
JY(SID)=Y1+INT(RAD(SID)*SIN(THETA(SID)*(PI/180)))
X1=JX(SID):Y1=JY(SID)

Six lines of code from a loop that specifies the radius,
an angle and the coordinates for control points in a pen stroke

Hodos.

I have named the software Hodos (ïäï´ ò), a Greek word meaning path or way. Note also that meta-hodos (µå´ èïäïò) is the classical root for “method”. Hodos, as a method of drawing, can be identified easily with my early work conceived as “pathways.” My studio, named Pathway Studio, received an oriental seal carved by the distinguished shufa master, Wang Dong Ling. Wang, awed by the brush strokes made with the “electric brain”, chose the classic expression xiao jing zhai, “little footpath studio”, as the seal for my studio. Many works executed in the studio receive this seal. (4)

Families of form.

Form generating routines within Hodos create works with distinctive features related to those routines. Works created with the same or similar algorithmic routines bear a familial resemblance to each other. Hodos can be set for a specific paper size, palette and sequence of routines to create a radically new kind of limited edition. It can generate a family of forms with each one being simultaneously related and yet uniquely “one of a kind”. Works share strong familial features because they share the same algorithmic parents. Familial variety occurs because the code draws on random decisions within shared parameters. Parameters within which decisions are made can be: (a) established as not more than or not less than; (b) wide open with no upper or lower limit; or (c) weighted as a percentage more or less than so much. Parameter settings establish factors like angle, radius, coordinates, scale and color. Familial resemblances between the works vary more or less greatly depending on how many parameters are set to change and to what degree.

For example, in 1990, with Hodos and my assistance, my wife Alice Wagstaff plotted 125 original pen and brush drawings as frontispieces and 125 as end-pieces for a limited edition. The leather bound edition of 125 included other algorithmic drawings illustrating Chapter II of George Boole’s 1854 classic, An investigation of the laws of thought. (5) One set of routines with a single set of parameters was employed for the frontispieces and another for the end-pieces. We believe this is the first time that a limited edition of a book engaged this kind of process for illustrations in a publication.

Epigenetic art: software as genotype.

These procedures are of a different order than traditional procedures. What shall we label this process? This was a question Alice and I posed in 1986. In our search we found ourselves returning again and again to similarities between biological processes and coded procedures. We settled on the term epigenetic and this became the basis for my 1988 paper.

Epigenesis refers to the process whereby a mature plant or phenotype grows from a seed or genotype. For example an acorn embodies the genotype or code that contains all the information needed for growing a mature oak tree. Given the proper environment it can, in time, grow into a mature tree. Through the process of epigenesis, the acorn grows into a mature tree referred to as phenotype.

By analogy my software or code, likened to genotype, contains all the information needed for generating an art form. Given the proper studio environment, the software literally grows from a coded procedure into an art form. By analogy to biological epigenesis, this process may be viewed as epigenetic.

Clearly any coded procedure that has all the information necessary for generating an art form could be viewed as epigenetic. The more general term used recently is generative art.

Content and meaning.

For over a quarter century epigenetic art has been creating the icons of our information age. One could think of these icons as diagrams or visual analogues to the coded procedures by which they were made. The essential character of each finished work is derived from the “form-generating-procedure” or “algorithm” acting as genotype. For this reason one could say that the finished work is an epiphany, or manifestation, of its generator, the code. For me each work celebrates its code, especially the recursive routines that shaped its character. It is noteworthy that such procedures hold much in common with processes associated with crystallization and genetics.

But these are generalities. How shall we approach specific work like an algorist pen and ink drawing, for example? Such drawings, at their best, will bear the imprint of the artist’s coded procedure. Just as a painter’s brush stroke may bear the unique mark of the painter’s hand, so the lines in an algorithmic drawing reveal the distinctive qualities of the composer’s algorithmic “mind-hand”. Through a unique convergence of conceptual innovation and knowledge of materials, the code created by each algorist engenders a personal style that is present with each drawing. The linear forms of an artist like Jean Pierre Hebert will celebrate themselves with self-similar meanderings coursing over the paper in a manner quite distinct from the character of the lines generated by my code or that of Manfred Mohr. Contemplating their forms reveals something, in each instance, of their creator’s “mind-hand”. Through these works we are given a glimpse into the mysterious nature of the algorist’s inner world.

In general these works provide a window on unseen processes shaping mind and matter. By doing so they become icons illuminating the mysterious nature of self, earth and cosmos.

(1)
www.verostko.com/algorist.htmlback

(2)
www.verostko.com/st/mural.htmlback

(3)
www.penplot.com/epigenet.htmlback

(4)
www.penplot.com/seal.htmlzurück

(5)
www.penplot.com/boole.htmlzurück

>> Erkki Huhtamo, "WEB STALKER SEEK AARON Reflections on Digital Arts, Codes and Coders", 2003

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

“..[A]ny notion of software leads us to reconsider our historical notions of art”

Jack Burnham, “Notes on art and information processing”, in the catalogue to the Software exhibition (1970)

1.

The mainstream of computing has evolved towards hiding the code. While producing and reading code was an everyday activity for early computer users - scientists, engineers, operators and even artists - the presence of the code has become more and more obscure, hidden behind the facade of the interface. Interfacing humans and computers in a “user-friedly” fashion has been one of the guidelines of the digital culture since the late 60s. For Nicholas Negroponte, writing in 1969, the real task was to teach the computer to understand humans, not vice versa: “A designer, when addressing a machine, must not be forced to resort to machine-oriented codes. And in spite of computational efficiency, a paradigm for fruitful conversations must be machines that can speak and respond to a natural language”. (1) The effort of creating “seamless” and “intimate” human-computer user interfaces became almost a definition of progressive computer culture, expanding from specialists to general users. From Xerox Star to the Apple Macintosh desktop and on to its bastard son, the Microsoft Windows, generations of users were taught to ignore the inner workings of the “box”. They dealt with software packages that opened their metaphor-filled offerings on the desktop by a mouseclick. The users saw icons of tools and trash cans, but no strings of zeros and ones - the program codes that actually power the whole system.

While the use of the computer has spread to all imaginable fields, direct access to the code and coding has remained a domain for specialists from computer scientists and professional programmers to hackers and builders of game engines. Mac users and even most Windows users rarely see even a glimpse of code. Even the brief revival of coding as a normal occupation for the general computer user as a result of the introduction of HTML, was soon obliterated by an avalanche of easy-to-use automated webpage authoring software. While this development can be justified by claiming that the computer is just an intermediary, a tool or a medium, and not a goal in itself, there is ample room for counter-arguments. The computer’s constantly expanding role as a universal machine powering innumerable applications and systems worldwide makes the invisibility of its workings alarming. Corporate and govermental coders (not to forget code breakers), as well as pranksters, cybercriminals and terrorists are monitoring and interfering with “innocent” computer use through the Internet. Lacking knowledge of programming, the users can only respond by subscribing to more corporate services or installing commercially marketed software packages. Yet both the core of the problem and the nature of the counter-measures remain vague. It has also been argued that merely using a pre-existing commercial software package restricts the user’s freedom of expression, forcing him/her unknowingly to adapt to a role envisioned by the corporate planners. (2) John Berger’s famous slogan, “every image embodies a way of seeing”, could perhaps be modified as “every software embodies a way of using”. (3) Gaining access to computer code, understanding its “message” and being able to use it for one’s own means are political, as well as social and economic issues. They are deeply intertwined with the dynamics of power and knowledge in contemporary society.

Against this background it is highly interesting to note the recent emphasis on coding within the field of the digital arts. This interest has manifested itself in various forms, particularly in the emergence of the discourse on “software art”. (4) In recent times we have witnessed the appreapance of artworks that modify the look and functioning of commercial software applications from web browsers to game worlds, introducing features that may be interpreted by users as formal interventions, disturbing pranks, ideological subversions or simply as technical bugs. The famous Web Stalker (I/O/D, 1997-) is a web browser that displays control codes and link structures instead of the usual graphical interface. Life_Sharing by 0100101110101101.ORG attacked the false openness of the web browser by giving anybody a permission to access its own hard disk with all its private files and programs through the Internet. (5) Other works use elements of computer code openly as building blocks of their aesthetics, without disguising them as graphics, images and sounds. Common to all these forms is the urge to question the prevailing conventions of computer use. Tearing down the veil of “user-friendliness”, seen as a deception, the artists are providing the users a look behind the scenes, to the engine room (to use an anacronistic metaphor). They themselves feel at ease in this engine room, using it as a laboratory, hangout, toolkit and venue for art. What are the reasons behind this interest? Is it enough to label it as an “inevitable” avantgarde of the digital culture? How will it relate to the wider, perhaps even non-digital, cultural context? This essay provides some preliminary answers to such questions by delving into the relationship between art, codes and coding from a media-archaeological point of view.

2.

The earliest computer artists in the 1960s were all coders. There was no alternative. Each work, whether graphics, animation or music, was necessarily the result of an unique act of writing computer code. As if foreshadowing the recent claims for “software art”, some pioneers, like Michael L. Noll and the members of the Japanese Computer Technique Group (CTG), openly stated that the true work of art was the generating program itself rather than the computer-produced output. (6) Most of the early work on computer graphics and music took a formalist path, exploring issues like the possibilities of generative grammars and the relationship between rule-based behaviour and randomness. This state of things is aptly mirrored by the diagram-dotted pages of Jasia Reichardt’s early overview, The Computer in Art (1971). (7) Pioneers of computer graphics like Frieder Nake described their activity as formal “visual research”, deliberately segregated from any social or political concerns. They found inspiration from cybernetics, Claude Shannon’s information theory and the exact mathematical aesthetics of theorists like Max Bense. (8) Bense excluded the role of subjective perception from his aesthetic system and based it on mathematical equations that emphasized the universal rather than the particular, the rational rather than the irrational (identified with the subjective art impulse), the abstract rather than the representational. Although random operations were often used by the early artist-programmers, the computer was considered mainly a “tool”: it was expected to execute a program written beforehand.

This situation can be explained both by the state of the technology and the institutional context. In the 1960s computers were mostly available at governmental and corporate institutions. They were used primarily for statistical calculations, which emphasized the act of programming in the form of batch-processing. Although the early artists and composers began to “bend” the technology to other kinds of uses, they were forced to accomodate themselves into the roles that had been established in the non-artistic “mainframe” culture: working within a dedicated institution, the artists created programs and then waited until they had been executed by the computer. They were members of a small elite, living on the fringe of a larger technical and institutional elite, exploring a powerful means of expression in its infancy. However, the nature of computing was constantly changing as a result of innovations like new interfaces, the idea of time-sharing, and the creation of the first programming languages meant for creative purposes. BEFLIX, written by computer scientist Kenneth Knowlton at Bell Labs, was applied to groundbreaking computer graphics and animation by artists Stan Vanderbeek and Lillian Schwartz, working in collaboration with Knowlton. Equally interesting was the appearance of the program ART 1 created by university professors Katherine Nash and Richard H. Williams and meant as a tool for artists interested in using the computer without having the theoretical and technical skills to program. Criticized at the time for considering the artist “as a specialist with pre-defined professional needs”, it was, however, an early pointer towards the parting of ways between the creators of “soft” digital art and those involved in writing algorithms. (9)

The proliferation of art using pre-existing software tools such as Photoshop or Maya has not meant the disappearance of the activity of creating original algorithms. Many of the most rigorous digital art projects have been created by artists who either write sofware for themselves or work in close collaboration with a programmer. Prominent examples of the first are Myron Krueger, Harold Cohen and David Rokeby, while figures like Jeffrey Shaw (in collaboration with Gideon May and Bernt Lintermann) and Rafael Lozano-Hemmer (with Will Bauer) represent the second type. In some cases, like that of Christa Sommerer and Laurent Mignonneau, separating programming from other aspects of creation is almost impossible. (10) Pioneers like Krueger, Cohen and Rokeby have spent years, even decades, writing program code to refine their increasingly sophisticated systems. The artworks these artists have exhibited over the years may have had own identities, but they can also be characterized as “materializations” of these systems, documenting their state of development. The code provides the core of Krueger’s Videoplace as well as Rokeby’s Very Nervous System and Giver of Names.(11) Arguably the most rigorous and longterm effort to use original programming as a means of creating an evolving art project has been Harold Cohen’s AARON, continuously under development since the early 1970s. (12)

AARON is an AI-based computer program, an expert system that creates paintings and drawings. Over the past thirty years, different output devices have been used, from a drawing “turtle” moving on paper placed on the floor to complex painting machines and more recently to a software application automatically creating pictures on the desktop. AARON can be characterized as a semi-autonomous creature. Its works are based on the complex rules defined by Cohen, but it also has a consideble amount of autonomy from composition to coloring. It is significant that Cohen has not made AARON’s code public. The different stages of the program have not even been systematically preserved, which is why the code’s development can only be deciphered indirectly, as reflected in AARON’s numerous drawings and paintings. (13) Although a major creative effort, Cohen never considered the code as the artwork proper. Rather, it can be likened to the skills and techniques accumulated by a human artist during his lifespan. What will remain are the paintings, the material traces of a lifework. In this sense Cohen, painter by education, resorts to a conventional model of the creation and preservation art. However, AARON’s most recent manifestation, the software application available as freeware on the Internet, could point to a more radical direction. (14) Instead of remaining Cohen’s own cybernetic extension, AARON has been given a degree of independence from its creator. However, while becoming a software application on anybody’s desktop, AARON’s development has also stopped. Although it can keep on producing different paintings endlessly, it does not have a facility to learn other routines. Moved to the desktop AARON certainly immortalizes Cohen’s achievement, but it also turns into a cybernetic zombie. Releasing its source code would give it a chance to develop further by means of collective programming efforts through the Internet. (15)

3.

The advocates of “software art” emphasize the primacy of the code as the main creative achievement and demand un-obstructed presence and role for it in the artwork. According to the statement of the first software art competition jury at the Transmediale 01, “software art is opposed to the notion of software as a tool”. (16) For the jury, software art has many faces: “it could be algorithms as an end to themselves, it could subvert perceived paradigms of computer software or create new ones, it could do something interesting or disrupting with your computer, it could be creative writing, it could be science.” In another text Mathias Cremer and Ulrike Gabriel (who were among the jury members) write: “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’”. (17) For these writers the principal “sin” media art has committed seems to be its excessive attention to interface design. For the software purist, the creation of detailed immersive environments and elaborate multisensory interfaces is in itself an act of mystification. Works that involve the participants both bodily and emotionally seduce them, instead of making them aware of the true nature of the system, hidden “behind the facade”.

It is highly interesting that interactive systems that in the not-so-distant past were seen as an empowering and critical alternative to “passivating” media experiences like watching television, have now become the target for criticism. This has to do with the rapid acceptance of interactivity and its adoption to the mainstream of digital culture. If interactivity was once seen as a gesture that questioned the prevailing logic of media, it has now been normalized, added to the internal cultural repertory. However, the recent criticism does not seem to be addressed to interactivity per se; rather, it addresses the way interactivity has been packaged and marketed, institutionalized and commodified. On fields like electronic gaming the near realtime interaction between the user and the game software/hardware complex has been claimed to lead to the “automation” of the action/reaction mechanism. Immersion into rapidly changing and emotionally engaging gameworlds leaves little time for reflecting on the algorithmic basis of the experience. (18)

For the gamer the system as if disappers, leaving only the phenomenological experience of the gameworld. The appearance of a phenomenon like game patch art is interesting in that it uses programming to directly address such mechanisms of identification. As a recent example, Anne-Marie Schleiner’s Velvet-Strike project (2002) invites people to create digital graffiti on the walls of Counter-Strike, the popular network shooter game about terrorism. (19) Situated somewhere between “textual poaching” gaming subcultures and critical software art, game patch art functions as an ambiguous counter-discourse to commercial game culture, true to the legacy of hackerism.

It should also be pointed out that media art from recent years has shown signs of self-reflectivity and a growing critical awareness of its own position vis a vis commercial and institutional applications. Works like Maurice Benayoun’s and Jean-Baptiste Barrière’s World Skin (1998) or Ken Feingold’s That Sinking Feeling (2002) are far from naive celebrations of the pleasures of the interface. While still offering memorable interactive experiences they at the same time disturb the bond with the user. (20) Both works create ambiguous situations where the seductive potential is constantly undermined by indiscrepant (World Skin) or deliberately “malfunctioning” (That Sinking Feeling) elements. Although neither work deals primarily with computer code, its role has by no means ignored. The functioning of the algorithmic base of these works may not have been highlighted, but its role is interconnected with the issues these works raise, from the role of media and the politics of simulation to social-psychology and the construction of identity. In their own ways they demonstrate that singling out the code for exclusive scrutiny at the expense of everything else may not be the right way to go in an integrated digital culture, where technical, ideological and cultural codes are no longer separable from each other.

4.

It is interesting to note that the software art purists have already begun to trace their own geneology. This proves the well-known fact that history is mainly written to justify the present. A major formative event in the pre-history of software art has been located in the Software exhibition, curated by Jack Burnham for the Jewish Museum in New York in 1970. This technically catastrophic and until now largely ignored event has been identified as the nexus at which the efforts to explore the creative potential of information technology met conceptual art and Burnham’s own interest in structuralist analysis. (21) In his introduction to the exhibition catalogue Burnham made it clear that Software was not a normal art exhibition. Rather, it displayed exhibits that dealt with “conceptual and process relationships”. One of the purposes was “to undermine normal perceptual expectations and habits which viewers bring to an art exhibition”. (22) The visitors were supposed to interact with various technological devices, without being asked to consider them as artworks. The most noted exhibit was SEEK, created by Nicholas Negroponte and his colleagues at MIT’s Architectural Machine Group. It was another AI-inspired programming effort that hardly reached its goals, except on metaphorical level: living gerbils had been placed on a glass-caged arena with aluminium building blocks, and a computer-controlled robot arm operating from above. The system, engaged in arranging the blocks according to pre-programmed schemes was supposed to respond “intelligently” to the “noise” created by the gerbils, bumping on the blocks, etc. (23)

For the software art advocates the most inspiring exhibit seems Labyrinth, an early version of Ted Nelson’s hypertext displayed as a bare branching structure. Several other exhibits interfaced visitors with technological apparata making few efforts to weave fictions or elaborate “stage-sets” around them. In Software Burnham drew a connection between the use of computing technology and conceptual art, which made him include non-technological pieces from artists like John Baldessari, Lawrence Weiner and Douglas Huebler. In Burnham’s view all these forms shared the tendency to move away from art objects and to investigate linguistic structures and forms of information exchange underlying other forms of expression. This was also in unison with Burnham’s simultaneous effort to reveal the mythical structures underlying the traditions of Western art. (24) Conceptual art, interpreted broadly to include also John Cage’s method of composition, the series of instructions for imaginary events composed by the Fluxus artists and some forms of lettrist poetry, certainly provide one possible background against which to assess the role of code in software art.

However, one might also refer to the field of structural and materialist film and the ideology of “anti-illusionism” in the film culture of the late 1960s and early 70s. Attacking the illusionism of conventional narrative cinema, filmmakers began to deconstruct the cinematic apparatus in its constituent elements. They emphasized the materiality of film, including sprocket holes, frames, emulsions, scratches and dirt. Some filmmakers, including Hollis Frampton, Michael Snow and the Croatian Ladislav Galeta, used (quasi-)generative principles to structure their films. In its most extreme form, filmmakers abandoned film altogether, staging events that merely highlighted the basic elements of the cinematic apparatus, the light beam from the projector, the screen, the darkness of the auditorium. Writing in the seminal Structural Film Anthology (1976), Peter Gidal defined Structural / Materialist films as “at once object and procedure”. (25) In another text he stated: “A film is materialist if it does not cover its apparatus of illusionism. Thus it is not a matter of anti-illusionism pure and simple, uncovered truth, but rather, a constant procedural work against the attempts at producing an illusionist continuum’s hegemony.” (26) In other words, materialist film was not a purification ritual as much as it was a constant struggle against the hegemonic forces resorting to illusionism.

5.

The struggles of the structural and materialist film movement could perhaps be compared with the efforts the software artists are currently making to scratch the slick corporate facades of cyberculture, metaphorically manifested in the deceptive openness and the pretended democracy of the graphical user interface. (27) Yet comparisons across time are risky. Drawing a parallel between a 1960s computer generated picture consisting of dense arrays of ASCII characters and a piece of “ASCII art” from the late 1990s is only valid in a limited sense. The student hackers that created Spacewar, considered the first computer game, have little in common with today’s commercial game developers and even with game patch artists. Similarly, the programming efforts of the computer graphics pioneers of the 1960s cannot be directly compared with the software art of the early 21st century, because of the widely different cultural contexts. The discourse on software art has emerged in a situation, where digital culture has already had time to create a history and a memory. During its first half a century, digital computing has gone through a number of different stages that have progressively re-defined the meanings of computing in warfare, administration, society, economy and culture. Issues like artificial intelligence, virtual reality, agents and avatars, A-Life, GUI, physical computing and digital networking are all elements in an evolving fabric that changes shape depending on time and place and the position and identity of the observer. Last but not least, software art is in a position to profit from the experiences of the net art pioneers.

Digital art has for some time shown signs of a growing self-conciousness in relation to the history of digital technology. Yet the recent interest in AI among artists does not mean an artistic revival of the classic artificial intelligence research. It is not a simple homage either. Projects like David Rokeby’s A Giver of Names, Kenneth Rinaldo’s Autopoiesis and Ken Feingold’s talking and responding puppet heads are examples of meta-art that engages in a dialogue with the cultural representations of AI (including, in Feingold’s case, Joseph Weizenbaum’s quasi-intelligent conversation program ELIZA), while pursuing at the same time other intellectual and ideological goals. Perhaps it is not wrong to say that there has been a cultural demand for a phenomenon like software art, just like there was for the appearance of structural / materialist film, which was “called for” by a conglomeration of conflicting cultural forces, from the increasing uniformity and untouchability of commercial film production to the impact of counter-cultural movements, the emergence of decontructionist philosophy and the “dematerialization of the art object”. Structural / materialist film movement emerged as a critical position that questioned the prevailing audiovisual hegemony, demanding an approach that highlighted the “primitives” of the filmic medium in dynamic interplay with its application to narrative and metamorphic purposes. In its anti-illusionistic fervor it evoked the idea of a modernist reaction, but not in a simple revivalist fashion.

The claims and prognoses made by the software art advocates also have a certain neo-modernist flavor. Emphasizing the centrality of the code and the algoritmic approach means positing a “hard core”, often felt to have been lost in the postmodern world. Indeed, there are “small but uninfluential” (to brutally appropriate an expression from Vuc Cosic) groups, such as the one dedicated to exploring the aesthetics of the generative code (Geoff Cox, Alec McLean, Adrian Ward, etc.), that fulfill many of the criteria for classical avantgarde movements. (28) Florian Cramer has identified the group’s activities, which include poetry readings in Perl program code, as “software formalism”. (29) On the other hand there are approaches that emphasize the cultural and ideological underpinnings of computer programming. For groups like the British Mongrel and I/O/D (creator of Web Stalker), digital code cannot be separated from the operations of ideology manifested on the Internet and elsewhere. Their actions and projects are much more difficult to fit into a modernist strait-jacket. The situation becomes even more difficult in the case of the independent artist-activists operating on the no-(wo)man’s land between popular cultural forms like gaming, various forms of net activism (including cyber-feminism) and theoretical approaches. Appropriation, pastiche, bricolage and other postmodernist tricks are still among their favourite tools.

If the digital arts are going to make a difference in the media culture of the 21st century, it is clear that they have to shed their veil of innocence. They have to face the problematic, conflicting realities of cyberculture. While doing so, they need to scrutinize and make public their own internal workings, as well as their relationship to the systems of power, control and commerce that envelop them, infiltrate them, co-opt them and influence their public image, whether welcome or not. Just as science and technology can never be free from the constraints imposed upon them by economy, culture and politics, the digital arts cannot be “pure” and “free”, even when purporting to focus on the quest for formal, mathematical, algorithmic beauty. Researching the aesthetics of digital grammars and exploring the workings of the code are important goals; yet getting the findings out from the isolated engine room and into the consciousness of the cyber citizen - also in the role of the cyberart lover - is quite another matter.

>> Christiane Paul, "Public CulturalProduction Art(Software){", 2003

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

The focus on notions of software as art has increased in recent years, which to some extent can be seen as a logical and inevitable consequence of the nature of the digital medium and the power of its structures and rules. Software is a driving force of the digital medium—a creative tool that is culturally and politically “encoded” and embedded in a commercial system.

Software is generally defined as formal instructions that can be executed by a computer. However, there is no digital art that doesn’t have a layer of code or algorithms, a procedure of formal instructions that accomplish a “result” in a finite number of steps. Even if the physical and visual manifestations of digital art distract from the layer of data and code, any “digital image” has ultimately been produced by instructions and the software that was used to create or manipulate it. It is precisely this layer of “code” and instructions that constitutes a conceptual level which connects to previous artistic work such as Fluxus’ and Dada’s experiments with formal variations and the conceptual pieces by Duchamp, Cage and Sol LeWitt that are based on the execution of instructions.

However, it is important to distinguish data constructs such as digitized images or texts from algorithmic code that enables generative processes. One has to make a major distinction between art that uses digital technologies as a tool in the creation process and results in a “traditional” art object (print, photograph, painting, sculpture), and art that employs the technologies as a medium—that is, art that has been created and is stored and presented by means of them. It is only the latter that can potentially exhibit generative processes in real time. Code also cannot be understood as separable from its overall structure. As Adrian Ward, Alex McLean, and Geoff Cox pointed out in The Aesthetics of Generative Code, (1) the written form of code—as “a notation of an internal structure that the computer is executing, expressing ideas, logic, and decisions”—is “a computerreadable notation of logic” and not what the computer really executes. The execution takes place through various layers of interpreting and compiling.

Software as art has been discussed in the wider context of generative art (for example at generative.net) (2) and has more recently been explored in the context of festivals such as Read_me (3) (explicitly devoted to this art form) and the software art award at Transmediale, (4) or the runme software art repository, (5) an open, moderated database that launched in January 2003. The introduction to the latter site describes software art as a crossover between two seemingly unrelated realms, software and art: while software culture is considered a “living substance” that to a large extent evolves on the Internet and stems from and permeates various cultural realms, art is traditionally presented in exhibitions in galleries and museums or at festivals. (6) The “software art” fusion consequently would introduce software culture into the art world and at the same time expand art beyond its institutional boundaries.

The consideration of software as an art form evidently raises a number of questions: can any software be considered art and, if not, where do we draw the line between software as art and software as a “mere” commercial product? To what extent is the identity of so-called “new media art” or digital art defined by its nature as art based on code? What are the aesthetics of software art and how can they be assessed by traditional art-immanent criteria (or should they be at all)?

Software = Art / (Product + (Formalism / Culturalism))

The Read_me 1.2 jury broadly defined software art as art based on code as formal instructions, or art offering a cultural reflection of software, definitions that cover a broad territory. If one takes a look at the subcategories listed on the runme repository's site, one encounters a landscape that may be fairly confusing in its topography but nevertheless makes important distinctions and can still be roughly summed up under the above mentioned definitions. Labels such as algorithmic appreciation, generative art, code poetry, data transformation, as well as digital folk and artisanship (e.g. ascii art and screen savers) arguably seem to put an emphasis on the aesthetics of formal instructions. On the other hand, classifications such as existing software manipulations (cracks and patches or plugins) or political and activist software (e.g. cease-and-desist-ware and software resistance) point to the role of software art as critical reflection of software's cultural status its encoded political or commercial agenda. Games, artistic tools, and conceptual software can fall into either of these two groups, depending on the execution of the respective project and the weight it places on formal aspects or critical reflection.

It would be difficult to argue that software—from Adobe Photoshop to Maya—can in and of itself be considered art. The “art aspect” manifests itself in artist-written software (concept, “writing style,” results of execution etc.) or the re-writing / re engineering of existing software as an act that examines the underbelly, inscribed aesthetics, and agenda of the original construct and thus opens it up to discussion. The inherent hope and promise here is that software production can be seen in the broader context of cultural production or, as Pit Schultz has put it, “that writing code has more meaning than making a program run or crash or sell.” (7) If one rephrases the above classification of software art—as either focused on code as formal instructions or on cultural reflection—as a manifestation of formalism vs. culturalism, one has to pose the question if these are opposite ends of a spectrum and if software art overall can be distinguished according to these categories. In “Concepts, Notations, Software, Art,” Florian Cramer outlines that much of contemporary software art takes two opposite approaches to software art and software criticism: either “software as first of all a cultural, politically coded construct” or a focus on “the formal poetics and aesthetics of software code and individual subjectivity expressed in algorithms.” (8)

The inherent dangers that Cramer identifies for each of these approaches are indeed important to note: as he puts it, a reduction of software art to the first one could make it “a critical footnote to Microsoft desktop computing” that neglects the potential of formal explorations; the second approach could result in “a neo-classicist understanding of software art as beautiful and elegant code.” The latter is exemplified in the criteria for evaluation established by computer scientist Donald Knuth, who has been talking about “computer programming as an art” since the 1970s (9): among these are correctness, maintainability, lucidity, grace of interaction with users, and readability (which would make the Obfuscated C Code Contest (10) a failure in the art of programming).

Cramer aligns the “software as cultural construct" school with artist-programmers such as Matthew Fuller and the group I/O/D or Graham Harwood and the group Mongrel. I/O/D single-handedly “established” alternative browsers as art form with their Web Stalker (11) [Fig. 1], an application that allows users to draw “frames” in a blank window and select information they would like to display in them – for example, a graphical map of the site that presents all its individual pages and the links between them; the text from a URL and the source code of the HTML page; a “stash” of URLs users would like to save.

Although the WebStalker didn’t display graphics, it expanded the functionality of existing browsers in a way that questions the paradigms of the conventional information display and Internet “architecture.” While different in its approach, Maciej Wisniewski’s netomat ™ (12) [Fig. 2], which abandons the page format of traditional browsers and treats the Internet as one large database of files, would fall in the same category. Using an audiovisual language designed specifically to explore the unexplored Internet, netomat™ reveals how the ever-expanding network interprets and reinterprets cultural concepts and themes and takes visitors for a ride into the Internet’s “subconscious.”

The approach of the formalism camp is, according to Cramer, exemplified by the groups revolving around Adrian Ward and Alex McLean and participants in the mailing list “eugene.” Adrian Ward’s Auto-Illustrator (13) (winner of the Transmediale.01 software art prize) is a graphic design application that allows users to play with a variety of procedural techniques in the production of their own graphic designs while Alex McLean’s forkbomb.pl (14) (winner of the Transmediale.02 software art prize) [Fig. 3] is a script written in Perl that creates an artistic impression of the user’s computer system under pressure (by repeatedly creating new processes at such a speed that the system comes to a halt).

While the emphasis of the above mentioned projects (or their “creators’” intent) may lean towards one side of the formalism / culturalism spectrum, it would be problematic to miss the more subtle pointers to the other side of the scale in each of these works. The WebStalker may engage notions of the browser as culturally coded construct, but one cannot neglect its distinct aesthetics and their art-historical references. In his essay Visceral Facades: taking Matta-Clark’s crowbar to software: (15), I/O/D’s Matthew Fuller establishes a connection between the WebStalker’s approach to information architecture and American artist Gordon Matta-Clark’s technique of literally “splitting” the existing architecture of buildings, an application of formal procedures that would result in a revelation of structural properties. Matta-Clark’s as well as the WebStalker’s “deconstructionism” and “anarchitecture” are as much statements against certain social conditions as they are aesthetic acts oscillating between reconstructions of the destroyed and destructions of closure. Ward’s Auto-Illustrator may be an application that explores the beauty and elegance of graphic design but at the same time makes a statement about the conventions and standardization of commercial graphic design applications. Taking a closer look at an artist’s body of work, it is often hard to align them with one camp or the other. Mark Napier’s FEED (16) [Fig. 4], which deconstructs webpages into a stream of pixels that are graphed and plotted in nine different displays, can almost be seen as an automization of aesthetic "strategies" from abstract expressionism to minimalism. Napier’s Riot (17), on the other hand, is an alternative browser that mixes text, images, and links from the three recent URLs that Riot users worldwide have accessed into one browser window and collapses territorial conventions like domains, sites, and pages. Illustrating how the Net resists traditional notions of territory, ownership, and authority, it questions the politics of encoding information. If software in general is not neutral but culturally encoded, there always is an interplay between formal and cultural aspects, which obviously varies depending on the emphasis of a specific project.

Aesthetics of Perception / Poetics of Construction

The categorization of artist-written software seems to undergo shifts depending on the manifestation the artwork takes. As mentioned above, any work of digital art incorporates a layer of code. It is noteworthy that digital art installations—even if they are ultimately driven by artist-written software—are seldom considered software art. Although the movements and reactions of robotic devices and objects (or the responses produced by sensors) may be driven or processed by artist-written software, little attention is commonly paid to the conceptual aspects, cultural impact, or “elegance” of the software itself, which remains a hidden force that isn’t foregrounded and often induces such complex interactions that its “writing process” simply isn't as accessible as that of a piece of code poetry. Understanding at least the basic nature and language of digital art and its foundation in code-driven or algorithmic processes is an important element in establishing its identity.

What is commonly accepted as “software art” today varies greatly in its focus and manifestation. Software art pieces can present themselves as anything ranging from visuals (driven by a largely hidden layer of artist-written code) or as the written code itself. Code poetry such as Graham Harwood’s London.pl (by William Blake) (18) would be an example of the latter category. Programming as artistic practice and expression remains largely undervalued and underappreciated. As Florian Cramer puts it, the focus on the purely perceptual aesthetics of art “is a straight continuation of romanticist philosophy and its privileging of aisthesis (perception) over poeisis (construction), cheapened into a restrained concept of art as only that which is tactile, audible, and visible.” (19)

What distinguishes software art from other artistic practices, is that, unlike any form of visual art, it requires the artist to write a purely verbal description of their work (which then often remains hidden behind the actions resulting from it). In most traditional art forms, the “signature” and “voice” of an artist manifests itself in aesthetics of visuals and execution. The aesthetics of artists who write their own source reveal themselves both in the poetics of the code and its visual results as actions derived from it. Artist John F. Simon, Jr. has repeatedly talked about code as a form of creative writing, where anything from the choice of story to the language of narration and the “story line” embody the artist's voice. Although Cramer sees Ward, McLean and Cox as largely privileging execution, they also emphasize that a separation of code from its resultant actions would result in a limitation of the aesthetic experience (20) and that both ends need to be considered.

The study and criticism of software art has to be equally literate in the aesthetics of the back end’s construction and the front end’s (multi-sensory) perception. The crucial dilemma of software art may very well be that the study of its “backend” will always remain a fringe culture that won't be integrated into the mainstream of (perception-oriented) art criticism. The interconnectedness of written code and the actions it produces also begs the question how transparent the relationship between these two forms can or should be, and whether this might be a criterion for evaluating the art. Meaning, is software art more successful if one can “see” the algorithms at work in the unfolding of visuals / sound and can establish direct connections between the front end and the code driving it? Art that allows this connection to be made will certainly be accessible to a wider audience but it remains questionable whether the transparency of cause-and-effect relationships is a criterion for the quality of art. The issue here seems to be one of reference and is embedded in a larger discussion surrounding the status of representation in digital art.

If one defines representation as a “likeness” or image of an external referent (an “object” or “scene” in the broadest sense), digital art in general ultimately represents data—be it an external data set or the data source of its own construction. While this applies to digital art in general, software art is more concerned with the generative construction process of data representation. One could draw the conclusion that we are facing a major transformation of the status of representation itself, which becomes a process that constitutes a convergence of language and mathematics, which in turn has the potential to drive a multi-sensory “display.”

This transformation of representation also implies that software art would be more contextdependent in that its data source is always embedded in a specific context. In software art that is focused on data visualization—the creation of visual models for data sets—the issue of context becomes particularly important. For any given set of data, there are multiple possibilities for giving it a visual form, which in turn lend themselves to reconfiguration. This again leads to contextual shifts: the context provided for creating meaning of any given set of data is to a large extent determined by the dynamics of the interface. In this case, an external referent, a set of data, becomes part of its own representation. Context also becomes key when it comes to the success of the visualization process itself. While there needs to be a certain focus on and reflection of the data changes at any point, the visual model tends to turn into a form of wallpaper (no matter how beautiful it is) if it loses the larger context of the data sets.

What complicates matters further is that software art by no means exists in an art-historical and cultural vacuum and constitutes a clearly separable realm in and of itself. The label “software art” may be just one distinguishing characteristic of an artwork that is embedded in multiple contexts. John F. Simon, Jr’s color panel series (consisting of custom hardware and software), for example, has strong art-historical references. Color Panel v 1.0 (21) is a time-based study of color in which Simon's software explores possibilities and "rules" for color as proposed by Bauhaus artists such as Klee and Kandinsky—an investigation of color theory in its relation to motion and time. It would be problematic to understand the project as a continuation of Bauhaus tradition without paying attention to the consecutive actions of the code that transcend a single moment in time and space and lead to continuous contextual changes.

There is a whole body of software art that references games and gaming culture—either by writing original games or rewriting and re-engineering existing ones—and has to be understood as an interplay of its contextual framework (games), the code, and its actions. Jodi’s “deconstructions” of the original Wolfenstein in their SOD (22) or of Quake I in their Untitled Game (23) [Fig. 5] cannot be “read” without being literate in the essential characteristics of video games (aesthetics, architecture, user vs. system control etc.). SOD replaces the representational elements of the original game with black, white, and grey geometrical forms and creates a new architecture that challenges both orientation and navigation. Untitled Game strips Quake of its original architecture, re-engineers its structure and interactivity, and uses the original game engine as a tool for the creation of abstract art. Cory Arcangel created several works (among them I Shot Andy Warhol and Landscape Study #4 (24) ) that are based on reverse-engineered cartridges of the Nintendo game Super Mario Brothers; the original chips are melted off a Super Mario cartridge and then replaced with his self-manufactured chips. One could assume that the appreciation of these pieces at least to some extent relies on an awareness of the “retro” aesthetics of their original context. Landscape Study #4 fuses traditional landscape photography with gaming aesthetics, creating a scenery that effectively transcends the media it borrows from and seems to evolve into a new manifestation of a pop art genre. The software works of John Klima—among them glasbead, Go, Fish, and ecosystm (25) [Fig. 6], which represents global currency data in a 3D environmental simulation, where the population and behavior of flocks of insect-like “birds” (representing countries’ currencies), are determined, respectively, by the currency’s value against the dollar and its daily/yearly volatility—are all deeply influenced by gaming paradigms or aesthetics. While all the artists above seem to work in the field of software art and gaming, their approach to programming and aesthetics is distinctly different and each of these artists’ body of work requires a different contextual frame.

The interest in developing criteria for the study and criticism of software art has been growing, but the question remains what impact this art will have both in the field contemporary art and culture at large. One could hope that a growing awareness of the arthistorical lineage between conceptual art and software art would lead to more acceptance of media art in the larger field of contemporary art. As Matthew Fuller has pointed out, contemporary art has already been engaging with networks and computation by exploring some of their characteristics, such as a “relational aesthetic,” but mostly without actually addressing specific digital technologies. (26) The question is not only what software art could do for the art world and its institutions but what these institutions could do for software artists. The nurturing of software and programming literacy is also essential when it comes to expanding the role of software in the broader context of cultural production. Initiatives such as Processing, an open project by Ben Fry and Casey Reas (27) (cf. p. 206) that creates an environment for learning the fundamentals of computer programming and is meant as an electronic sketchbook for developing ideas, are a step in that direction. At this point in time, there still needs to be a much broader appreciation of software as art and cultural expression in order to reach a level where software is more than an off-the-shelf product that is judged mostly by its efficiency.
}

(1)
Adrian Ward, Alex McLean, and Geoff Cox, “The Aesthetics of Generative Code,” http://generative.net/papers/aesthetics/back

(2)
www.generative.net/ “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.” (Adrian Ward) “Generative art refers to any art practice where the artist creates a process, such as a set of natural language rules, a computer program, a machine, or other procedural invention, which is then set into motion with some degree of autonomy contributing to or resulting in a completed work of art.” (Philip Galanter)back

(3)
www.m-cult.org/read_me/back

(4)
www.transmediale.deback

(5)
www.runme.org; developed by Amy Alexander, Florian Cramer, Matthew Fuller, Olga Goriunova, Thomax Kaulmann, Alex McLean, Pit Schultz, Alexei Shulgin, and The Yes Menback

(6)
www.runme.org/about.tt2back

(7)
“QuickView on Software Art,” runme.org/project/+quickviewback

(8)
Florian Cramer, ”Concepts, Notations, Software, Art” (2002), http://userpage.fu-berlin.de/~cantsin/homepage/writings/software_art/concept_notations//concepts_notations_software_art.htmlback

(9)
Donald E. Knuth, “Literate Programming,” CSLI Lecture Notes. Number 27. Center for the Study of Language and Information. Stanford, CA, 1992back

(10)
www.ioccc.orgback

(11)
I/O/D, WebStalker, www.backspace.org/iodback

(12)
Maciej Wisniewski, etomat™, www.netomat.netback

(13)
Adrian Ward, Auto-Illustrator, www.auto-illustrator.comback

(14)
Alex McLean, forkbomb.pl, www.slab.orgback

(15)
Matthew Fuller, “Visceral Facades: taking Matta-Clark’s crowbar to software,” www.backspace.org/iod/Visceral.htmlback

(16)
Mark Napier, FEED, www.potatoland.org/feedback

(17)
Mark Napier, Riot, www.potatoland.org/riotback

(18)
Graham Harwood, London.pl by William Blake, www.runme.org/project/+londonplback

(19)
Ibid. [8]back

(20)
Ibid. [1]back

(21)
John F. Simon, Jr., Color Panel v 1., www.numeral.com/panels/colorpanelv1.0.htmlback

(22)
Jodi, SOD, sod.jodi.orgback

(23)
Jodi, Untitled Game, www.untitled-game.orgback

(24)
Cory Arcangel, I Shot Andy Warhol, Landscape Studies, beigerecords.com/coryback

(25)
www.cityarts.comback

(26)
Ibid. [7]back

(27)
http://proce55ing.net/back

>> Casey Reas, "Programming Media", 2003

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

The design of software is a defining factor in modern culture and is increasingly becoming a basis for our reality. Citizens of the world unite in spending their lives staring into the reflective surfaces of their mobile phones and desktop computers. Their minds and hands operate in the space between reality and the arbitrary rules of menus, windows, clicking, and dragging. Artists utilize software to comment on our increasingly digital social and political structures and to challenge the underlying formal assumptions of computer code. Regardless of the content or intent of their work, contemporary artists are expressing their ideas through the medium of software. With the continually shifting focus of the electronic arts (Cybernetics, Virtual Reality, CAVE, A-Life, Net.art, Augmented Reality), software provides the foundation on which meaning and content are constructed. With the revitalization of the concept of “software art” at festivals such as the Transmediale and READ_ME, a critical discussion is emerging around the role of software within our culture and art practice. This essay extends the discourse and focuses on the concept of software as a medium capable of unique expressions and programming languages as materials with specific properties.

SOFTWARE DEFINED

What is Software?
Software is written in programming languages, sequences of alphanumeric characters and symbols composed according to rigid syntactical rules. (1)
If you do not normally see computer programs, here are a few program fragments for reference:

Perl
opendir(DIR, $dir) || die $!;
@files = readdir(DIR);
closedir(DIR);
foreach $file (@files) {
if($file =~ ".xml") {
handle("$dir/$file");
}
}
C++
main() {
int c;
c = getchar();
while(c != EOF) {
putchar(c);
c = getchar();
}
}
LISP
(define (square x)
(* x x))
(define (sum-of-squares x y)
(+ (square x) (square y)))

Through writing software, computer programmers describe structures that define “processes.” These structures are translated into code that is executed by a machine and the processes are carried out by actively engaging the electronic matter within the computer. Massachusetts Institute of Technology computer scientist Harold Abelson explains, “Processes manipulate abstract things called data. The evolution of a process is directed by a pattern of rules called a program. People create programs to direct processes.” It is this active process of reading, manipulating, and storing data, that enables the unique aspects of the software medium.

Software is a Medium
Software has enabled a way to build a bridge between the art of the past and the electronic arts of the present and future. As articulated by Roy Ascott, we have transitioned from “content, object, perspective, and representation” to “context, process, immersion, and negotiation.” The most unique aspect of software as a medium is that it enables response. A responsive artifact has the ability to interact with its environment. Artificial reality pioneer Myron Krueger suggests a number of interesting metaphors for interactions between people and software including dialog, amplification, ecosystem, instrument, game, and narrative. I am interested in addressing expressions of software that are more fundamental than those discussed by Ascott and Krueger. These expressions are the foundation of the software media and include dynamic form, gesture, behavior, simulation, self-organization, and adaptation.

Each Language is Unique
Just as there are many different human languages, there are many different programming languages. In the same way that different concepts can be conveyed through diverse human languages, different computer languages allow programmers to write diverse software structures. Just as some expressions are not translatable from one human language to another, programming structures often cannot be translated from one machine language to another. Some programming languages were built specifically for business applications (COBOL), some for artificial intelligence exploration (LISP), and some data manipulation (Perl), and many of the structures written within these diverse languages can only be expressed within that language. The abstract animator and programmer Larry Cuba describes his experience, “Each of my films has been made on a different system using a different programming language. A programming language gives you the power to express some ideas, while limiting your abilities to express others.”

Programming Languages are Materials
It can be useful to think of each programming language as a material with unique affordances and constraints. Different languages are appropriate depending on the context. Some languages are easy to use but obscure the potential of the computer and some languages are very complicated, but provide total control through providing complete access to the machine. For example, some programming languages are flexible and others are rigid. Flexible languages like Perl and Lingo are good for quickly creating short programs, but they often become difficult to maintain and understand when programs become large. Programming with rigid languages like 68008 Assembly or C requires extreme care and tedious attention to detail, but the results are efficient and robust. In the same way that the different woods Pine and Oak “feel” and “look” different, software programs written in different languages also have distinct aesthetic gestalts. For example, similar software programs written in Java and Flash have unique differences that are noticed by people familiar with both.

Programming is Exclusive
Many people think that computer programmers are a unique kind of person, different from everyone else. One reason programming remains within the boundaries of this type of personality is that similarly minded people usually create the programming languages. It is possible to create different kinds of programming languages that engage people with visual and spatial minds. Alternative languages expand the programming space to people who think differently. An early alternative language was LOGO, designed in the late 1960s by Seymour Papert as a language concept for children. Through LOGO, children are able to program many different media including a robotic turtle and graphic images on screen. A contemporary example is the MAX programming environment developed at IRCAM by Miller Puckette in the 1980s. MAX has generated enthusiasm from thousands of artists who use it as a base for creating audiovisual software and installations. The same way the graphical user interfaces (GUIs) opened up computing for millions of people, alternative programming environments will continue to enable new generations of artists working with software.

SOFTWARE EXPRESSIONS

When computer programs execute, they are dynamic processes rather than static texts on the screen. Core expressions of software including dynamic form, gesture, behavior, simulation, self-organization, and adaptation emerge from these processes. These and other basic expressions are the fundamentals on which more complex ideas and experiences are conveyed. Each expression is discussed below and illustrated with an example from the Aesthetics & Computation Group at the Massachusetts Institute of Technology. These examples were created by hybrid artist/programmers from 1998 – 2001 and provide clear demonstrations of software expressions.

Dynamic Form
Dynamic form is form that changes in time. If this form reacts to stimuli, it is responsive. Scratch by Jared Schiffman (Figure 1) demonstrates basic qualities of dynamic form. In this software, the position of a controllable circle continuously affects the contour of each visual element. Scratch augments the visual communication of the form by adding layers of movement and fluid response. In general, form can respond to any signal from the environment including common input devices such as a mouse, microphone, and video camera to more exotic devices such as radiation sensors and sonar.

Gesture
Gesture is a critical aspect of every continuous medium and software has the ability to convey and interpret gesture. The AVES software by Golan Levin (Figure 2) is a group of applications that amplify hand gestures by processing their data as sound and image. One application maps the structure of each gesture into sounds that reflect its degree of curvature. Another layers gestures to create gradual sound textures that activate and combine with the presence of the cursor. Interpreting gestures is more complex, but opens new opportunities for engaging interaction. Handwriting recognition software is one application of gesture interpretation. Some installations and video games use a more basic form of gesture recognition to allow people to direct action with complex motions.

Behavior
Behavior is movement with the appearance of intent. Combining simple behaviors can create personality or disposition. Behavior can be created by intuitively writing programs or by implementing biological models. In the project Trundle (Figure 3), the physical object has a program that determines how it should move when presented with stimuli in its environment. Trundle searches the environment looking for people, but when it finds someone it attempts to flee. It is curious and timid. An array of sensors on Trundle’s body continually monitors its immediate environment and sends signals to the micro-controller that determines how the motors should turn. In general, behavior can be used to actively engage the mind through personifying objects, developing characters, communicating affect, and adding a layer of psychological interest to a piece of software.

Simulation
Simulated aspects of the physical world provide an easy access point for perceiving works of software. Our senses have evolved to respond to the rules of the natural world. One of the first computer games, Pong , was a highly abstracted simulation of tennis. Modern engineering and scientific communities utilize models of reality as a basis for designing physical objects and conducting research. The Floccus software by Golan Levin (Figure 4) creates a group of elegant lines, each a connected list of simulated springs. The undulating movement created by this simple simulation generates awe in spectators when it is combined with response. The lines stretch and contract according to force, mass, and acceleration. In software, simulation can go beyond mimicking perspective, materials, and physical laws—the processes of natural systems can be simulated as well.

Self-Organization
The ability for elements to self-organize makes possible the phenomena of emergence. Structure emerges through the interactions of many autonomous processes. Valence by Ben Fry (Figure 5), reads the text of a book word by word and spatially organizes it according to a system of rules. A complex volume emerges from the relations of diverse words in the text. Small changes to the rules of interaction make potentially large changes in the processed visualization.

Adaptation
Adapting is the ability to change. For software to adapt, it must have a representation of itself and be aware of its context. The Anemone software by Ben Fry (Figure 6) is able to monitor its density and prune its structure to maintain equilibrium. Anemone is a visualization of website traffic and as the hours and days progress, the software removes sections of its mass to allow for new sections to grow without obscuring legibility of the information. Writing software that truly adapts to its context is a challenge and adaptive expressions are rare. Using an interpreter, it is possible for a program to modify its own program while it is running.

Programming

Although software is consistently utilized within the electronic arts, individuals choose to construct their code in radically different ways from writing in low-level languages to collaborating with programmers. Some artists use software as a tool for creating work in other media. They use commercially available products for generating prints and videos and for making rough sketches that are executed in analog media. Others collaborate with professional programmers by creating specifications that are then implemented by the programmers. Many other people use programming environments developed for designers and artists. They create their work with scripting and visual programming environments such as Director, Flash, and MAX that make it easier for non-programmers to construct software. The smallest group of artists working with software use programming languages developed for professional programmers. They use general languages like C, Java, and Perl and often develop their own custom tools for working within these environments.

There is no correct way to work with software. It is an individual choice balancing control with simplicity. Mastering programming takes many years of hard work, but understanding the basic principles of the medium is within everyone’s grasp. In my opinion, every artist using software should be software literate. What does literacy mean within the context of software? Alan Kay, an innovator in thinking about computation as a medium, has written: The ability to "read" a medium means you can access materials and tools created by others. The ability to "write" in a medium means you can generate materials and tools for others. You must have both to be literate. In print writing, the tools you generate are rhetorical; they demonstrate and convince. In computer writing, the tools you generate are processes; they simulate and decide.

These processes that simulate and decide are the essence of software and they can only be fully understood through constructing them.

Artists are increasing writing their own software. With the growth of the web, the popularity of scripting environments like Flash, and the falling price of hardware, many more artists are exploring programming. The area of audiovisual programming is an excellent example of this trend. Small software companies like Cycling ’74, the developer of Jitter, are very responsive to their community of artists and foster the development of enabling tools. Their Jitter tool is a sophisticated library of visual structures for integrating image with sound. Many artists have moved beyond relying on developers for their tools. The Pink Twins, a duo of musician/programmers from Helsinki, have created Framestein, video processing software that links to PD, open source real-time software for performance. The German artist collective Meso has gone even further with vvvv, an ambitious library of tools for real-time video synthesis. Some artists develop software tools for themselves and after a period of refinement, choose to release it to the community.

SYNTHESIS

Over the last thirty years, artists have created innovative work with the aid of the software medium, but they have explored only a small range of the conceptual possibilities. Historically, programming languages and environments encouraged a specific methodology that did not engage the majority of artists who were interested in creating interactive and programmatic work. New tools are emerging that encourage artists to begin working directly with the software medium. The proliferation of software literacy among artists will increase the sophisticated use of software and contribute to new forms of software materials and development environments. These materials and environments have the potential to open the creation of software to an even larger creative and critical community.

(1)
There are exceptional programming languages called “visual programming languages” that allow structures to be defined with graphic symbols.back

Abelson, Harold, Gerald Sussman, and Julie Sussman. Structure and Interpretation of Computer Programs. MIT Press, Cambridge, MA. 1985

Ascott, Roy. “Moist Ontology.” Published in The Art of Programming. Sonics Acts Press, Amsterdam. 2002

Cuba, Larry. “Calculated Movements.” Published in Prix Ars Electronica Edition ’87: Meisterwerke der Computerkunst. Verlag H.S. Sauer. 1987

Kay, Alan. “User Interface: A Personal View” in The Art of Human-Computer Interface Design, edited by Brenda Laurel Addison-Wesley Publishing Company, Reading MA. 1989.

Krueger, Myron. “Responsive Environments.” Published in Multimedia, From Wagner to Virtual Reality.
Edited by Randall Packer and Ken Jordan. W.W Norton & Company, Inc., New York. 2001

>> Christiane Paul, "CODeDOC", 2002

from: http://www.whitney.org/arport/commissions/codedoc/index.shtml

"CODeDOC takes a reverse look at 'software art' projects by focusing on and comparing the 'back end' of the code that drives the artwork's 'front end'--the result of the code, be it visuals or a more abstract communication process. A dozen artists coded a specific assignment in a language of their choice and were asked to exchange the code with each other for comments. The assignment was to 'connect and move three points in space,' which obviously could be interpreted in a literal or abstract way. The 'core' of the code (commonly referred to as the 'main') was not to exceed 8KB, which equals a fairly short text document. The results of the programming are made visible only after the code--what visitors to this site encounter first is a text document of code from which they can launch the front end of the project. The languages in which the code is written are Java, C, Visual Basic, Lingo and Perl. Obviously, this is only a selection of scripting and programming languages. HTML (Hypertext Markup Language), the scripting language on which the World Wide Web is based, and Flash Script were excluded mostly for pragmatic reasons (the inclusion of these languages probably would have doubled the number of artists, making the project unwieldy). Not all of the artists originally invited were able to participate in CODeDOC due to their busy schedules.

The category of software art, commonly used for artist-written software, is a manifestation of fairly blurry terminology. Software is generally defined as formal instructions that can be executed by a computer. However, there is no digital art that doesn't have a layer of code and algorithms, a procedure of formal instructions that accomplish a 'result' in a finite number of steps. Even if the physical and visual manifestations of digital art distract from the layer of data and code, any 'digital image' has ultimately been produced by instructions and the software that was used to create or manipulate it. It is precisely this layer of 'code' and instructions that constitutes a conceptual level which connects to previous artistic work such as Dada's experiments with formal variations and the conceptual pieces by Duchamp, Cage and Sol LeWitt that are based on the execution of instructions.

What distinguishes software art from other artistic practices, is that, unlike any form of visual art, it requires the artist to write a purely verbal description of their work. In traditional art forms, the 'signature' and 'voice' of an artist manifests itself in aesthetics of visuals and execution. Every medium may have its specific language but in digital art, this language has a quite literal rather than figurative manifestation. In software art, the visual results of the artwork are derived from the language of code. Languages are defined by grammar and complex rules and at the same time leave space for individual forms of creative expression. Our identity and the roles we play are expressed in our use of language. One might assume that the aesthetics of artists who write their own source code manifest themselves both in the code itself and its visual results. Artist John F. Simon, Jr. (who wasn't able to participate in the project) has talked about code as a form of creative writing. Code has also been referred to as the medium, the 'paint and canvas,' of the digital artist but it transcends this metaphor in that it even allows artists to write their own tools--to stay with the metaphor, the medium in this case also enables the artist to create the paintbrush and palette.

The projects featured as part of CODeDOC are expressions of distinct artistic signatures: the conceptual approach to the project, the way the code has been written, and the results produced by it reveal a lot about the respective artist. Some of the artists interpret the assignment in a predominantly graphic, visual way; others connect points in the global network of the Internet; one project explicitly treats the language of code as a narrative connecting 3 'characters'; another one creates a meta-layer for profiling the code itself, collapsing the boundaries between front end and back end; yet another project focuses on 'language abuse' and illegal instructions.

Intrinsic to software art is a procedural element that allows for reconfiguration and extension, and, as way of commenting on the projects, artists started to 'remix' their work, applying their own code to other projects or combining sections of code into a new project.

One does not need to be a programmer and have an in-depth understanding of computer languages to establish a connection between the code and its respective results: even a glance at the artists' source code will reveal certain mathematical functions, and in many cases, the artists' comments on their writing clarify the functionality of a line or section of the code. In some cases, reading the source code will enhance the perception of the work; in other cases, the code doesn't necessarily add to the projects. CODeDOC is an endeavor to take a closer look at the process of this particular artistic practice, and to raise questions about the parameters of artistic creation."

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