Pay attention to the Code behind the screen. Amy Alexander, Margarete Jahrmann, David Rokeby From Transmediale '03 Software Jury Essay. (Full jury statement available at: Any piece of computer software exists on two levels. On the one hand, it exists as an executing program supporting some sort of activity or generating some sort of experience. On the other, it exists as a text in its own right, a subjective expression of the writer's ideas and an example of one person's struggle to give form and function to an idea in the particular medium/language of executable code. The human reader has an immediate and direct relationship to the 'source text' of a poem or novel, rendering it into an imagined experience using their comprehension of language, their memories and life-experiences. On the other hand, a computer program's text is generally hidden, interpreted by the processor, operating system and hardware before being presented to the audience. But the inaccessibility of the program's source code does not make the code-text itself culturally irrelevant. In the case of executable computer code, some of the interpretive activity is shifted away from the human into the machine/code system. This combination of human-written code and human-designed machine is a complicated expressive mechanism that cannot simply be reduced to a function of its surface effects. As poetry and literature can be understood as struggles with the mechanism of a particular language and the limits of language itself, software art on this reflexive level can be seen as a struggle with the mechanisms of a computer language and the acts of quantifying, encoding and logical processing. This engagement is a central yet deeply hidden and underexamined activity in contemporary culture; its importance is amplified by its invisibility. When software art reflects upon questions of coding and its implications, *is* it important to read the actual program text to experience or evaluate it? In much software art, the particular way that an executing algorithm hooks into its cultural context is key to the understanding of the work. LAN's "SuPerVillainizer" is manifest primarily in the way that its algorithms actively seek to become "targets" of surveillance. By algorithmically caricaturizing actual events, the project ties into and questions the data surveillance tactics of the war on terrorism. In other cases, the code itself is very verbal rather than purely algorithmic, and this verbal content may either clarify the concepts behind the work, or constitute an important part of the work itself. Such is the case, for example with McLean's "", where reading the source code adds layers to the meaning of the executing code. Since it does not make sense to force code literacy on everyone, what sort of strategies can be pursued to open the implications of code-texts for broader discussion? A conceptual framework that allows one to discuss software-related issues without descending to implementation specifics would be a valuable tool. But reading and understanding the code-text itself is not enough. Such a framework or meta-language must not be merely an abstract representation of code function and code structure, but also a way of talking about the ways that coding actions ripple out through executing machinery to affect the social context. An algorithm may be a simple representation of a mathematical or logical equation. But even a simple and easily understood algorithm can be a provocative agent in the complex system of the world. Software defines processes, which reflect and transform the complex world that surrounds them. An algorithm can be thought of as a person's way of making sense out of data. Code transforms the significance of data, and the data that code is applied to changes the significance of the code. They form contexts for each other. Artists and corporations often process the same data through very different kinds of algorithms bringing radically different interpretations of the data. Choosing to put an algorithm into play in the world is an expressive decision that cannot and must not hide behind the apparent objectivity and "innocence" of the algorithm as an isolated logical entity. And finally, it must be recognized that a program's implications go further than its functional presence in the world. It also engages a set of expectations that the culture or the individual user brings to it. A piece of software plays a role in culture, and that role can be as much defined by the way it is perceived as by what it actually is. Software art can open the door to reflection on software's role in culture. By exposing its texts - literally and through opening itself up to analysis and critical discussion - software art exposes its own subjectivity. So it gives us a handle on examining the texts of software at large, which normally hide "behind the curtain" of interface, output, the illusions of pure utility and transparency, and the fiction of 'objective' technology. Looking at software coding as a form of expressive text writing opens up another question: Does an examination of this form of writing offer new perspectives on other forms of text-based representation? Software coding exists at one extreme of the continuum of text writing. Extreme cases often clarify middle positions. Virtually all writing involves processes of formulation, encoding and compression and a deferred but implicit process of interpretation. Software art, by maintaining a consciousness of the interrelationship between the underlying code, the code's functional operation, and the cultural ramifications of the code's execution, offers the opportunity to examine new perspectives on the concepts of language, text and expression.