Interrogating the Interface: The Glitch in Software Art 2010
Katie Turnbull
The use of glitch in software art provides an indeterminate outcome, and thus can be a
mode of creative production classed as 'open' as stated by Daniel Agnihotri-Clark. To draw a
parallel of such ‘openness’ that predates software art, Umberto Eco discussed the notion of the
'open' work in regards to the work of John Cage. Cage can be seen as a predecessor to the glitch
music movement (Cascone), which has had direct influence on it's aesthetic counterpart: the
visual glitch. Cage’s method of creating music through destruction (scratching vinyl records to
produce music) and his emphasis on the use of chance, were the foundations of the glitch
movement. Eco argued that Cage's work reflected philosophies of the intellectuals of the time;
the open-ended universes of Einstein, Heisenberg, and Bohr. The idea of the 'open work' can be
recontexualised in the current cultural landscape, where the mechanical and electronic have been
replaced by the digital. Thus the study of glitch now necessitates further enquiries into this new
relationship to computer code.
The main aim of this research is to explore how the use of glitch in software art uses the
human computer interface (HCI) to interrogate the parameters of software construction
and design, and in light of this exploration, consider if software art provides a valid
framework in which to re-think the function and use of commercial software1 .
The case studies, all modifications of software using elements of glitch, will be studied in light of
three complimentary ideas: Lev Manovich’s theories of digital media, in regards to the role of
software tools and functions; Soren Pold, who establishes the paradigm of software culture
within the theoretical framework of interface aesthetics; and finally, Rosa Menkman’s Glitch
Theory. Other theorists writing in various fields of new media will be used in support as the
subject matter crosses a range of interrelated disciplines.
Background
In Manovich’s latest book, Software takes Command, he states: “I think of software as a layer that permeates all areas of contemporary
societies. Therefore, if we want to understand contemporary techniques of
control, communication, representation, simulation, analysis, decision-making,
memory, vision, writing, and interaction, our analysis can't be complete until we
consider this software layer. Which means that all disciplines which deal with
contemporary society and culture – architecture, design, art criticism, sociology,
political science, humanities, science and technology studies, and so on – need to
account for the role of software and its effects in whatever subjects they
investigate” .
Although this text does not cover all the implications of software mentioned in the
above quote, it exemplifies that software is a multi-faceted area of study with many
overlapping definitions. And, as a practitioner in the field of ‘new media’, a critical study
of software is crucial. The New Media Reader , edited by Noah Wardrip-Fruin and Nick
Montfort (The MIT Press, 2003) was a seminal text written on the field of software.
Unlike previous texts before it, that were grounded in engineering practices, the New
Media Reader introduced a new area of study, “Software Studies”. As Manovich stated: “Although the Reader did not explicitly use the term “software studies,” it did
propose a new model for how to think about software. By systematically
juxtaposing important texts by pioneers of cultural computing and key artists
active in the same historical periods, the Reader demonstrated that both belonge to the same larger epistemes”.
In this climate of literary awareness, the notion of software as a conceptual medium and an artform in itself, rather than simply a tool, is also gaining currency. In 1999 the operating
system ‘Linux’2 won first prize, the Golden Nica, in the .net category at Ars Electronica, an
internationally recognized electronic art competition and festival. This was the first time
software had won in the .net category and moreover had been considered art, as Florian Cramer
stated, “software code is a conceptual notion” (1). The Transmediale festival started in 1998, as
‘VideoFilmFest’, a side-project of the Berlin Berlinale’s International Forum of New Cinema. It
describes its function on the website as: “to present advanced artistic positions reflecting on the
socio-cultural impact of new technologies. It seeks out artistic practices that not only respond to
scientific or technical developments, but that try to shape the way in which we think about and
experience these technologies”. In 2001, Transmediale introduced an award solely dedicated to
software.
An online, open and moderated repository for software art, runme.org is a database where
artists can upload and discuss the realms of software and art and how to understand the new
cultural form this crossover makes. From runme.org a new festival was spawned in Moscow
2002, the read_me festival, which is dedicated solely to software art. As their mission statement
from the runme.org website reads, “the subject of the festival is software art, a realm where people with artists' self-
identities coexist with programmers whose views on the process of creation, distribution and even the very meaning of their work can be dramatically different
from those of the artists”.
Key contributors to the festival and the database are; Alex McLean, Amy Alexander, Alexei Shulgin, Olga Goriunova, Pit Schultz, Florian Cramer, Soren Pold, Matthew Fuller, The
Yes Men, and Thomax Kaulmann. Perhaps unsurprisingly, some of these contributors also make
up a body of key theorists in the realm of software art. Software is becoming of greater socio-
political interest and importance as digital culture grows. These festivals and communities reflect
the growing dissemination of the ideals and the start of critical writing on the subject of software.
Glitch is a break in the flow, where the function gives way to error. Menkman presents glitch as method to disrupt expectation, in
the case of this paper, expectation of function.
I began to think that the creative use of glitch raised questions regarding software design,
but did not provide a solid answer. Glitch is a protest, but doesn’t seem to know what comes
next. So I started to investigate newer forms of software art, so as to point to a new re-working of
software. In consideration of the use of glitch and other forms of tactical engagement with
software by artists, I will also draw attention to Processing, an example of a programming
language and software, which is currently open source and free, developed expressly as a
platform for digital art practice. Open source free ware allows users to play an integral role in the
development and design of software.
In light of McLuhan’s statement, “we shape our tools, then our tools shape us”, how does
the use of glitch in software art suggest a further re-shaping of our tools? McLuhan’s statement was made in relation to the major innovations which changed the way the
world was perceived and also changed the manner of perception. When McLuhan wrote the
statement he referenced the invention of print and how the eye became the primary consumer of
knowledge as opposed to what was an oral history, he traced how this shifted not only how
knowledge was shaped but how humans thought. This shift “encouraged people to think in
straight lines and to arrange their perception of the world in forms convenient to the visual order
of the printed page”, as stated by Lewis Lapham in the introduction to Understanding Media by McLuhan (xi-xii). The same shift in perception occurred with the invention of electricity and
with the Internet. As the personal computer becomes more ubiquitous this statement is worth
investigating in relation to the tools of electronic communication and expression.
My hypothesis is as follows: the tools and functions of software are not neutral
facilitators, they are constant mediators; as seen through Manovich's post-digital transmission
diagram:
SENDER-SOFTWARE-MESSAGE-SOFTWARE-RECEIVER. (Manovich, Post-
Media Aesthetics, 17-18)
As stated in the diagram, software affects the creation of the message and also mediates the
output. By establishing discourse around software as a cultural form, the structure of software
can then be disassembled and interrogated through the use of glitch to reveal certain aspects of
cultural assumptions or political bias, and to suggest new ways of working, new aesthetics and a
new cultural form.
Software art focuses and experiments with the core structures of the digital realm
according to Pold (17). The purpose of glitch is to expose the workings and the flaws of
technology. When these areas of study or practice come together what new ideas and forms
emerge? The use of the glitch in software will be the main focus of study, with reference to three
case studies: Auto-Illustrator by Adrian Ward, %WrongBrowser by JODI, and Forkbomb.pl by
Alex McLean.
Clarification of terms:
Glitch: Glitch in a visual manner, but may also be applied to other forms of recorded media, is “an artifact resulting from error” –Moradi (8). Moradi also makes the distinction
between the ‘pure glitch’ and the ‘glitch-alike’. The ‘pure glitch’ is an “unpremeditated digital
artifact” as defined by Moradi, and the latter ‘glitch-alike’ is when “glitch artists either
synthesise glitches in non-digital media, or produce and create the environment that is required
to invoke a glitch and anticipate one to happen”(10). This exegesis utilises the term glitch in the
sense of what Moradi would characterise the glitch-alike’4, deliberate re-creations of glitches.
Menkman declares, “The glitch has no solid form or state through time; it is often perceived as
an unexpected and abnormal mode of operandi, a break from (one of) the many flows (of
expectations) within a technological system”(5). In this exegesis, glitch is discussed as a ‘raw’
display of the inner workings of a system, associated with a malfunction or imperfection within
that system.
This transparency of system functionality allows us to further “engage with the interface
and makes us see through and in it” (Pold, 1). By this engagement with and dissembling of
software systems and functions, Deleuze and Guattari’s term ‘deterritorialisation’ is demonstrated; cultural assumptions perceived by artists as embedded within structures of
software design provoke artistic intervention to the point where software design itself becomes a
contested space. This deterritorialisation is played out through glitch, hacking and sampling
practices, as stated by Agnihotri-Clark and can be defined as, “where a functional equilibrium
gives way to a change or becoming... a decoding” (1). This collapse of function generates
mistakes, randomness and unpredictability thus rendering the process indeterminate (Young 48).
Software: In this paper software is divided up into two sub categories under the
banner of software, the first being the structure, the second being the interface. These two areas
are of equal importance although the on-screen, visible Graphical User Interface (GUI) has
traditionally been given higher importance when it comes to the history of computer arts, a
tendency one might view as continued from the Romanticist tradition of aesthesis over poesis,
perception over construction (Cramer, 1).
Structure: The structure is the backbone of software, that is, what we don’t see. The
structure of software is a logical process, according to MIT professor Harold Abelson,
“processes manipulate other abstract things called data. The evolution of a process is directed by
a pattern of rules called a program. People create programs to direct a process” (1). Software is a
logical set of instructions executed in order.
The Graphical User Interface (GUI): The GUI is a display format that uses icons and
windows to allow a user direct input and to interact with a computer. To dismantle software an
understanding of the history of software and the origins of the interface is necessary. Manovich traces the origins of the interface to cinema. Cinema, the most prominent cultural form of the
20th century has been re-interpreted to be “the toolbox of the computer user” (The Language of
New Media 84). Cinematic ways of working; the construct of time and space, recalling memory,
montage and perspective have all been referenced and translated into software. Cinema presents
a window into a world of fiction; software presents a window into a world comprised of
algorithmic data. As Manovich discussed, “Cinema’s aesthetic strategies have become basic
organisational principles of computer software...what was cinema is now the human-computer
interface” (The Language of New Media 84).
The design of the Graphical User Interface (GUI) is grounded in the metaphor of real life,
it is a “re-formatting (of) other media, both past and present - the printed page, film, television”
(Manovich The Language of New Media 89). This reliance on the man made physical world as
design metaphor is problematic as it grounds the virtual in the physical and the physically
impossible in the possible. Manovich gives the example of the 1970s designers at Xerox PARC,
predominantly Alan Kay, and the modeling of the GUI as an extension of the actual physical
desktop as that was how they imagined the computer to be used.
The history of the interface has given rise to critical writing on the subject and the
resulting cultural issues. The interface was intended to be seamless, transparent and above all
intuitive, born from an engineering custom that has tried to make it invisible rather from an
aesthetic custom (Pold 2). Manovich coined the virtualisation of culture as, “the automation of
all cultural operations”, and that a “side effect of this automation is that once particular cultural
codes are implemented in low-level software and hardware, they are no longer seen as choices
but as unquestionable defaults” (The Language of New Media 85). Software and interfaces contain ideals created by an engineer of how the software should be operated, they engineer not
only software but also a user (Lillemose 114).
Auto-Illustrator by Adrian Ward 2000-2003
Auto-Illustrator is a modified version of Adobe Illustrator where the algorithms of the
code behind the tools have been altered, thus altering the function. The tool box sets from Adobe
Illustrator CS have been replaced by parodies of the original settings; the icon metaphors for the
desktop are gone and replaced by bugs and obscure iconography. These icons do not function
under the metaphor they have been assigned. These parodies have their own seemingly
‘autonomous will’, i.e they are programmed to misbehave. When the user selects the line tool, it
draws a pattern. When the user draws circles or squares, the software draws childish houses and
scribbled faces. The user cooperates with the software (Pold, 32). The user’s intentions are
thwarted by the denial of service, instead, in the quest for creating content, the user makes
allowances for the software. The user’s control is compromised.
As Fuller stated, “objects carry utopias with them, imaginary worlds of ideal use and misuse...”
(29). Adrian Ward’s Auto-Illustrator can be seen as an anti-utopian parody of Adobe Illustrator.
By taking the control away from the user and giving the software seemingly autonomous will,
along with quasi-random generative abilities, Adrian Ward’s Auto Illustrator can be read in
conjunction with Manovich's post-digital transmission diagram: “SENDER-SOFTWARE-
MESSAGE-SOFTWARE-RECEIVER” (Post-Media Aesthetics 17-18). This mediation becomes
evident as the relationship between user and software is physically severed, the hand no longer
completely controls the actions the user sees on the screen. As Pold states, “Auto Illustrator
questions the implied perceptions in ordinary software, of the user as the active artist/author, and of the software itself as a passive tool”(24). This abnormality intentionally made apparent by
Ward’s ‘faulty’ software demonstrates how glitch is used to break expectations of designed
functionality.
Although the outcome of Auto-illustrator (the illustrations), are not of concern in reference
to this exegesis, the use of glitch renders the software’s outcome indeterminate, which is one of
the aims of glitch as stated in Menkman’s glitch manifesto:
“Within software art, the glitch is often used to deconstruct the myth of linear
progress and to end the search for the holy grail of perfect technology. In these
works, the glitch emphasizes what is normally rejected as a flaw and subsequently
shows that accidents and errors can also be welcomed as new forms of usability.
The glitch does not only invoke the death of the author, but also the death of the
apparatus, medium or tool (at least from the perspective of the technological
determinist spectator) and is often used as an anti ‘software-deterministic’ form”
(7).
Glitch takes the control away from the user and simultaneously exposes software’s
contingent relationship on code. Menkman presents the code used as a virulent/
malevolent? form that can change the output of the software and the software itself. The main interest does not lie in the output of Auto Illustrator rather the software itself,
specifically the interface. This is evident, for example, in the Auto Illustrator preferences palette.
The preferences palette in most software is the area where the user has a small insight into the
structure of the software. Here they can make limited customisations in line with the logical
construction of the software: turn on/off certain default functions, re-arrange the interface and
designate their preferred ‘default states’ of classes of tools in the ‘tool preferences’. In Auto
Illustrator’s preferences palette, however, under ‘General’ the user can curiously choose to
unregister the software, under ‘interface’ comes the option ‘mess up palettes’, and under the
‘Psychosis’ tab comes the important ‘Don’t push this button’.
Buttons are an integral element of interface design, as Pold states, “buttons have aesthetic
qualities and respond to a desire to push them” (15). Ward’s labelling of a button with ‘don’t
push this button’ paradoxically increases the urge to push the button, but also acts as a refutation
of the functional expectations of users (Pold, 15). The appearance of “tactical control and
mastery...(are) strong ingredients in the aesthetics of the interface, even when denied”, as stated
by Pold (15). This button further severs the cause-and-effect relationship between user and software. When the button is pressed the software interface ‘disappears’ and is replaced by
fractured, flashing windows.
The software apparently ceases to work and artefacts of the software code appear in the
windows and the interface slowly slides down the screen until it is no longer visible. “The clear
distinction between the data and the program, which is necessary in order to sustain the illusion
of functional software, is cancelled” as stated by Pold (15) and through this cancellation the user
no longer views the interface as a tool but rather sees through the interface and is made aware of
the representational form (Pold, 15), thus further highlighting software’s mediation as seen in
Manovich’s post-digital transmission diagram.
As Young wrote on the term glitch, “(it) suggests simultaneously a slippage of gears or
wheels- a failure to engage- and a scratch, a small nick in a smooth surface that recalls Gilles
Deleuze’s statement that the smoother the surface, the easier it is to deterritorialise” (48).
The ‘smooth surface’ of Adobe Illustrator’s software finds its territoriality in designed cause-
and-effect function; Adrian Ward deterritorialises the function of this particular Graphical User
Interface (GUI), and by implication design principles of the GUI in general, through glitch. This
deterritorialisation renders the materiality of the interface as Anderson and Pold states, “visable,
readable, audible, navigable and so forth ...(which) contributes to the development of the
interface by making sure that it does not become invisible, transparent, subservient to the
task”(17). The functional relationship between user and interface ‘wysiwyg’ (‘what you see is
what you get’) or as Lillemose puts it, “the three-clicks-and-you-are-where-you-want-to-be
logic” (124), when broken, becomes a frustrating, occasionally humourous, but overall
unnerving experience. This experience of alienation from designed functionality allows the user
to gain an awareness of the mediation in software and exposes the software’s hampered
restrictions enforced by the limiting range of the tool metaphor (Pold, 13).
%WRONGBrowser by JODI 2001
%WrongBrowser is a modification of the traditional web browser. The URL is entered in
the top part of a coloured square and when the enter key is pressed the website is displayed in code. Navigation is still possible within each square, as the links are still active. The user can
surf an endless wave of data. Each coloured square represents a window and they can be move
about by selecting the smaller coloured square in the top left corner.
JODI’s %WrongBrowser displays websites in their ‘pure’ code, HTML (Hyper Text
Mark-up Language). The websites’ links are still accessible and this way provide a warped
navigation through code, sound and colour. When the World Wide Web predominantly
contained websites made in HTML, to encourage others to make and understand how HTML
worked, all viewers of the website were able to access the code under the ‘View Source’ menu.
According to the ‘Institute for New Culture Technologies’ website, “It dates from a time when
the web was struggling for popularity and the first Mosaic browser spread a "How-to-do-this"
button with every page html”. With the rise in both specialist literacy and the somewhat
interrelated popularity of making websites in ‘Flash’5 the code was no longer accessible.
Although this is not integral to the work of JODI, they often utilise this forgotten relic, in
previous works, JODI6 has played on the ‘View Source’ option by placing the content of the
work in the source window, rather than the browser window.
JODI’s utilisation of glitch provides a slippage in the façade of function presented by the
interface in software. Glitch acts as an x-ray machine to explore the inner workings of software
in all its algorithmic beauty but simultaneously exposes its flaws and limitations. The user
expects browsers to behave in a certain manner, to deliver information. As quoted from the
‘Institute for New Culture Technologies’ website, JODI states, “... users are conditioned by the "real7" browser. "Users" are "used" to watching "comets-falling-over-the-small-upper-right-
corporate-Logo"8 and looking at "the-lower-left-side-of-your-frame" to read and believe they are
%Connected and %Downloading”. By turning this information into code jargon the cultural
function that Manovich ascribes to software becomes realised in %WrongBrowser (Barker parr.
4).
The history of the interface and it’s subsequent ideals of use create the base upon which
JODI subverts, as Menkman states:
“This system consists of layers of obfuscated protocols that find their origin in
ideologies, economies, political hierarchies and social conventions, which are
subsequently operated by different actors. Some artists set out to elucidate and
deconstruct the hierarchies of these systems of assemblage”.
JODI uses glitch through self-reflexivity to expose the inherent expectations of the user,
whose relationship with technology is one based on obedient functionality,
“They do not work in (binary) opposition to what is inside the flows (the normal
uses of the computer) but practice on the border of these flows. Sometimes, they
use the computers’ inherent maxims as a façade, to trick the audience into a flow
of certain expectation that the artwork subsequently rapidly breaks out of”
(Menkman ).
This denial of function through glitch, forces an awareness in the user, “As a result, the spectator
is forced to acknowledge that the use of the computer is based on a genealogy of conventions,
while in reality the computer is a machine that can be bend (sic) or used in many different ways”
as stated by Menkman . JODI works within the limitations of HMTL and the window metaphor of the Internet, they reveal the abstract nature of the language of code and demonstrate
the structural materiality of the interface (Pold).
Forkbomb.pl by Alex McLean 2002
Forkbomb.pl is a program that repeats the same process in quick succession. The
processes are created so quickly that the computer can no longer work and ‘crashes’. As McLean
stated in an artist statement from the runme.org website:
“This particular fork bomb outputs binary data while flooding the machine. This
data is patterned partly by the algorithm represented in the code, and partly by the
operating system it executes within. A computer operating system is in a constant state of change, and so the script will produce different results every time. The output is an artistic impression of your system under strain”.
Forkbomb explores the structure and the processes of software through the language of
code. The code for forkbomb.pl is as follows:
my $strength = $ARGV[0] + 1;
while (not fork) {
exit unless --$strength;
print 0;
twist: while (fork) {
exit unless --$strength;
print 1;
}
}
goto 'twist' if --$strength;
McLean has created program code that can conceivably be executed, but in doing so, once
started, cannot be stopped and will inevitably lead to arrest of the computer’s capacity to
compute. This work recall’s La Monte Young’s instructional composition, Draw a straight line
and follow it, 19619 which is also conceivably possible when imagined but the action of
physically undertaking this task is impossible (Johansson 156). Both works test the limits of
language in a self-reflexive manner, “closed off from the reference function of language, the
concept has thus become emblematic for the instability and fragility of representation” as stated
by Johansson .
The efficiency of language when writing code is paramount, software is engineered upon
efficiency. McLean presents us with a code that is so efficient to the point of self-destruction.
This denial of service code creates a glitch in the system, which (usually) also manifests itself as
a visual glitch on the screen. The glitch in Forkbomb operates in two ways, it transforms the functioning computer to a broken, dysfunctional state thus the glitch can transform the medium
from how the “consumer perceives the normal” (Menkman 7) and simultaneously offer a critique
on the medium, “(genre, function and expectations)...They challenge its inherent politics and the
established template of creative practice while producing a theory of reflection” Menkman (7).
The work achieves transparency through self-reflexivity, Forkbomb reveals the materiality and
contests the structures of code through using code and thus reveals language as the foundation of
all software and simultaneously exposes it’s inherent limits (Anderson and Pold 12).
Discussion
Contemporary software art and the surrounding dialogue has branched from two separate
groups working in the realm of software art according to Cramer, Software Culturalism and
Software Formalism (6). Fuller makes a similar distinction but rather than classifying them as
separate groups, simply categorises approaches to software art as social software and critical
software10, as noted by Cox, McLean et al(167). Software Culturalists, “regard software as first
of all a cultural, politically coded construct” (Cramer 6). Culturalists tweak, bend, break and re-
purpose software, focusing on the interface to highlight it’s importance to the culture and the
medium (Johansson 153). Software Formalism focuses “on the formal poetics and aesthetics of
software code and individual subjectivity expressed in algorithms” (Cramer 6). In response to the
creation of this division Johansson wrote a rebuttal to Cramer11, claiming the self-reflexivity
present in all software art is a binding element, thus they should not be considered two entirely
separate entities (153). Both areas utilises program code and do not focus on the output. Rather,
Software Cultralism can be seen to focus on the GUI and Software Formalists focus on software structure. Whether or not this exact divide exists is not the focus of the exegesis, this exegesis
examines case studies from both the Culturalist (Auto-Illustrator and %WrongBrowser) and the
Formalist (Forkbomb) areas.
From the Culturalist perspective Auto-Illustrator and %WrongBrowser are works that
primarily interrogate the GUI and therefore a critical analysis of interface culture is necessary in
working towards a re-shaping of the tools it shaped. The interface is integral to all digital art, as
it forms the base on which the virtual can be formed, like literature to books and painting to the
canvas (Pold 1). In turn digital art reflects the role of the interface, as stated by Pold, “as an
aesthetic, cultural and ideological object...digital art explores the materiality and cultural effects
of the interface’s representationality” (3). This raises the question of a bias present in software
that not only influences use but also output. As Golan Levin stated, as transcribed from his talk
on Software (as) Art on TED.com, he’d noticed the “great homogenising force that software
imposes on people and limits the way they think about what’s possible on the computer”. He also
noted in defence of the computer, that it is a powerful tool and enables users a broad range of
tasks, “ it’s also a great liberating force, it makes possible publishing and so forth...(but) The
computer makes possible so much more than people think”. These statements by Pold and Levin,
posit that the output of software is heavily mediated and limited by the structure and the design
of the interface. The interface carries within it cultural ideologies and ideals of use, thus it has
limits when attempting to use software in a way it has not been intended to be used (Agnihotri-
Clark 8).
Software Formalism is based on the structure of software and centres around code and the
relationship between software and language. As clarified in the definition of structure, software
is a set of executable instructions (Cramer ). By this definition Sol le Witt’s ‘Wall Drawings’ can be viewed as software12 (Reas ). ‘Wall Drawing #53’ (1970) reads, “Serial drawing with
lines in three directions (vertical, horizontal, diagonal-left or diagonal-right) and three colours
superimposed in each part” (Concept Art). The disconnection between the concept and
manifestation is comparable to the relationship between code and user (Reas ). This relationship
in Sol Le Witt’s work raises issues that are pertinent in the study of Forkbomb, as the
implementation and concept are one. Sol le Witt’s code has a direct semantic relationship to the
execution, and the code is also ‘open’ in the sense it can be modified and is open to some
interpretation resulting in a dynamic output. This comparison between structures in ‘Wall
Drawing #53’ and Forkbomb, explicitly reveals the limitations and short-comings in the
language of computer based code in the pursuit of correctness and efficiency.
Software Culturalism and Software Formalism can be seen to make different
criticisms of software, the Culturalists interrogate the interface and the Formalists expose
the structural limitations of language. Through glitch these practices represent two
different critiques on software as a tool and their critiques are similarly impaired by the
meta-nature of their form, their critique is formed in the medium they are critiquing.
Formalism critiques “risk ending up with a neo-classical understanding of software art as
beautiful and elegant code” (Cramer ) and Culturalism “could end up being a critical
footnote to Microsoft desktop computing, potentially over looking its speculative
potential at formal expression” (Cramer).
These forms of Software Art cannot answer the questions they pose; an alternative format
is necessary in the concrete re-shaping of our tools (Johansson ). An aim or rather a
repercussion of Software Art as cited by Pold is to see how it can feed back into its own development(3). The use of glitch in software art raises issues regarding: the origins of interface
design steeped in an engineering tradition, expectations of information, the abstract nature of
code, the language of code and software structure. A possible answer can be found in the
‘alternative format’ of open source free ware and projects such as Processing, the C5
corporation, Free Art and Technology (FAT) Lab and the rise of forums and participation
cultures.
Open source provides a re-shaping of tools as users can feedback into the continual
development of their tools. Processing13 is an example of a programming language and
software, which is open source and free14. Javier Candeira, in appraising Processing in his
interview with Benjamin Fry and Casey Reas, asserts, “Your tool is not only a tool, like
Photoshop or Illustrator, but a tool for artists to make their own tools” (2) There are plug-ins for
Adobe Photoshop and Illustrator made for and by artists, to extend and modify use. But the plug-
ins are often commercial and not open source. They do not feed back into the development of
Adobe products, they lack the community of Processing. This culture of re-shaping is necessary
as Lillemose posits “for de- as well as re-coding. In the name of free information flows, open
source, creative commons and tactical media use it wants to get... behind the culture of software
and revitalise the desire for digital creativity and the sense of digital life” (143). The idea of a
virulent code is elucidated in both Auto-Illustrator and Forkbomb, this idea is remedied in
Processing as users have access to a library of all the code created by other users and can modify
and use it as they see fit. This has led to rapid development in Processing as a tool and a medium as users are constantly adding to the body of knowledge. Processing is a “Programming
language, development environment and teaching methodology (in)... a unified system” (Fry
and Reas ). Unlike other programming languages’ (such as Java and C++) top-down
structure, Processing is based upon allowing the user to focus on small modules of code, that
doesn’t require a large structure (Fry and Reas ). This shift in structure may also be as a
result of the shift in language. The Processing language has a more direct semantic relationship
with what it creates.
The C5 Corporation “specializes in cultural production informed by the blurred
boundaries of research, art and business practice. Theory as Product” as stated on their website
C5corp.com. Not all their work is software, but the projects SoftSub and 1:1 utilise software in
particular, the interface to create new methods of use and exploration. 1:1 is of particular interest
as it explores the same issues of the browser as JODI’s %WrongBrowser and re-works the GUI
into five new modes of navigation outside the window metaphor. They are: “hierarchical: the
web as directory structure, every: a complete mapping of all web servers in the database, petri:
clusters of networks and navigational traces, random: randomly generated IP addresses from the
database and excursion: provides access to the unsearched places of the web” (C5corp.com).
SoftSub is free software application that manifests itself as a screen saver, but is used t gather research on the “dynamics of the relationship between files, folders, system, and desktop configurations (on the user’s computer)” (C5corp.com). The projects feedback into the development of the GUI in software.
Eben Moglen15 stated in his talk, Free and open software: paradigm for a new
intellectual commons, “ (open source) insures that the evolving network could not be biased at the invisible, technical level through the ownership of the software that made
it”. In this way open source free ware provides an answer to questions raised by glitch in
software art, open source software such as, Processing allows for a continual, transparent
and indeterminate re-shaping of our tools where the engineering base and passive
consumption of software is replaced by a flat-hierarchy of user input and modification.
Conclusion
McLuhan’s statement of “We shape our tools, then our tools shape us” is cyclical in
nature, as it presents a succession of developments as a result of the previous one. After ‘our
tools shape us’ we in turn re-shape our tools and so on. We shaped commercial software, which
engineered a set of parameters and glitch through software art responded, as Andreas Broegger
stated:
“A large part of the so-called software art projects investigate the ways in which
ideology is encoded into mainstream software - browsers displaying html code in
particular ways, search engines crawling through the web according to certain
parameters, software companies deciding which features should be built into their
applications, interface designers engineering the user according to their ideal of
"usability", and so on.”
The case studies explore the representationality and materiality of software through
glitch. The artists’ conscious utilisation of glitch works within the parameters of software
and exposes, bends and breaks them, and attempts to re-form them to make the user
aware that the functions of software exist wholly within their original design parameters
and the inherent limits (arising from assumptions made, on the part of designers, vendors
and users, about these design parameters). Thus the user/designer must question and re- think their tools and how software mediates and shapes the output. In this way glitch in
software offers a re-reading of McLuhan’s statement, as it offers an awareness of how the
tools we shaped, now shape us.
Software art, as stated by Lillemose, can be read in a cultural and political context as a
comment on a “society of control” (142). Lillemose likens it to the one described by Michael
Hardt and Antonio Negri16, “A society where power is exercised through machines that directly
organise the brains (in communication systems, information networks, etc)...toward a state of
autonomous alienation from the sense of life and the desire for creativity” (23). Artists working
with software art criticise from within the medium; in other words, the criticism takes form in
what they are criticising, software as a culture for reforming. Software art inhabits the realm of
software, the same realm as the engineered commercial software they are criticising, this
dichotomy presents a problem as software art falls prey to the very limitations and parameters it
hopes to expose. While glitch asks questions and makes demands of the software it provides no
answers in terms of a structurally intrinsic re-shaping of tools.
The glitch in software art can be seen as an –un-shaping of our tools, a provocation, a kind of
(cultural) ‘answer’ to the habits of tool shaping, that has the potential to make us, the users,
aware of the bias present in software. This increased awareness in turn has resulted in a re-
thinking of an alternative user input orientated paradigm so as to allow for a constant re-shaping.
With the open source movement and mode of user input development, the re-shaping of
our tools has in turn re-shaped us. The evolutionary approach to open source free ware has been
integrated and embraced by commercial companies and used as an engineering strategy. In the
paper, Rethinking software design in participation cultures, Fischer highlights the shift from, “an industrialised information economy (specialised in creating finished goods to be consumed
passively) to a cyber-enabled networked information economy (in which all people are provided
with the means to participate actively in personally meaningful problems)” (abstract). Fischer
signals three different inter-relating approaches to software engineering: “a reuse and redesign
perspective, an evolutionary approach supported by the seeding, evolutionary growth, reseeding
model (SER) and a collaboration approach supported by participation cultures” (ch 1). He based
the SER model on the observation that, “design problems in the real world require open systems
that users can modify and evolve...(the systems) need to contain mechanisms that allow users to
modify functionality and content” (ch 4). These approaches to software signal a step in the new
evolution and further the cyclical nature of McLuhan’s statement, as Processing was developed
as a way of ‘moving outside’ the dominant paradigms of software design, it has become in itself
a recognised strategy that is coopted by mainstream software vendors and ultimately an expected
mode of operation by software users .
These expectations have shaped new free ware, that are user orientated with modifiable
content, such as Google, Twitter and Facebook. These wares are provocation for interrogation
and a new wave of artists, such as the Free Art and Technology (FAT) Lab with their Facebook
hacks, are exploring these new modes of communication in the same manner as glitch in
software art. These works are a continuation of the technological/cultural/aesthetic cycle of
McLuhan’s statement, "We shape our tools, then our tools shape us", they raise new questions
and offer further grounds for research.
Bibliography
Abelson, Harold, Gerald Sussman, and Julie Sussman. Structure and Interpretation of computer
programs. Cambridge: MIT Press, 1985
Agnihotri-Clark, Daniel. "Indeterminacy and Interface." (2005) Project MUSE. RMIT
University, Melbourne, Victoria. 12 Apr. 2010 <http://muse.jhu.edu/>.
Anderson, Christian and Soren Pold. "Software art and cultures- people doing strange things with
software." Read_me: software art & cultures. Ed. Olga Goriunova and Alexei Shulgin.
Aarhus: Digital Aesthetics Research Centre, University of Aarhus, 2004. 11-17.
Barker, Tim. “Error, the Unforeseen, and the Emergent: The Error and Interactive Media Art.”
M/C Journal, 10.5(2007). 10 Apr. 2010 <http://journal.media-culture.org.au/0710/03-
barker.php>/.
Broegger, Andreas. “Special: Software Art.” Artificial. 2001. News resource for computer based
art forms. 13 Apr. 2010 <http://www.artificial.dk/articles/software.htm>C5: Theory as
product. 06 June 2010 <http://www.c5corp.com>.
Cascone, Kim. “The Aesthetics of Failure: ‘Post-Digital’ tendencies in contemporary computer
music.” Audio Culture: Readings in Modern Music. Ed. C. Cox , D.Warner. London
:Continuum, 2004."Concept Art." Radical Art. 29 May 2010
<http://radicalart.info/concept/LeWitt/index.html>.
Cox, Geoff, Alex McLean and Adrian Ward. "Coding Praxis: Reconsidering the Aesthetics of
code." Read_me: software art & cultures. Ed. Olga Goriunova and Alexei Shulgin.
Aarhus: Digital Aesthetics Research Centre, University of Aarhus, 2004. 160-176.
31
Cramer, Florian. "Florian Cramer: Concepts, Notations, Software, Art." Netzliteratur.net:
Netzliteratur // Internetliteratur // Hyperfiction // Netzkunst. 23 Mar. 2003. 01 June 2010
<http://www.netzliteratur.net/cramer/concepts_notations_software_art.html>.
Deleuze, G. and Guattari, F. Kafka: Toward a minor literature. Minneapolis: University of
Minnesota Press, 1975.F.A.T. 04 June 2010 <http://fffff.at/>.
Eco, Umberto. “The poetics of the open work.” Audio Culture: Readings in Modern Music. Ed.
C. Cox , D.Warner. London: Continuum, 2004.
Fischer, Gerhard. "Rethinking software design in participation cultures." Automated Software
Engineering Journal 15. 3 Sept. 2008. 23 Apr. 2010
<http://portal.acm.org/citation.cfm?id=1459076>.
Fry, Benjamin, and Casey Reas. "Working the art process by typing in computer code."
Interview by Javier Candeira. Visual Communication, 05(.2006) Sage Online. RMIT
University, Melbourne, Victoria. 29 Apr. 2010 <http://online.sagepub.com>
Fuller, Matthew. "Digital Objects." Read_me: software art & cultures. Ed. Olga Goriunova and
Alexei Shulgin. Aarhus: Digital Aesthetics Research Centre, University of Aarhus, 2004.
26-42.
Golan Levin on software (as) art | Video on TED.com. Perf. Golan Levin. TED: Ideas worth
spreading. Apr. 2007. 20 May 2010
<http://www.ted.com/talks/golan_levin_on_software_as_art.html>.
Hardt, Michael and Antonio Negri. Empire. London: Harvard University Press, 2000.
"Institute for new culture technologies." Institute for new culture technologies. Ed. Sonja
Eismann and Eva Preßl. 01 June 2010
<http://web.archive.org/web/20080405074022/http://interface.t0.or.at/virtual/vp03.html>.
32
JODI. %WrongBrowser. Computer software. Vers. 8.02. 17 May 2010
<http://www.wrongbrowser.com/>.
Johansson, Troels Degn. "Mise en Abyme in Software Art: A comment to Florian Cramer."
Read_me: software art & cultures. Ed. Olga Goriunova and Alexei Shulgin. Aarhus:
Digital Aesthetics Research Centre, University of Aarhus, 2004. 150-160.
Lapham, Lewis. Introduction. Understanding media: the extensions of man. By Marshall
McLuhan. Cambridge, Mass.: MIT P, 1994.
Lillemose, Jacob. "A re-declaration of dependence- software art in a cultural context it can’t get
out of." Read_me: software art & cultures. Ed. Olga Goriunova and Alexei Shulgin.
Aarhus: Digital Aesthetics Research Centre, University of Aarhus, 2004. 136-50.
Manovich, Lev. "Locations." Post-Media Aesthetics. Karlsruhe: ZKM:Centre for Art and Media,
2001. 17-18.
---. Software takes Command. 2008. 7 May 2010
<softwarestudies.com/softbook/manovich_softbook_11_20_2008.pdf>.
---. "The Interface." The language of new media. Cambridge, Mass.: MIT P, 2002. 74-89.
McLean, Alex. "Forkbomb.pl." Runme.org - say it with software art! 17 May 2010
<http://runme.org/project/ forkbomb/>.
Menkman, Rosa. Glitch Manifesto.website. 29 Mar 2010
<http://rosa-menkman.blogspot.com/2010/02/glitch-studies-manifesto.html>
Moglen, Eben. "Free and open software: paradigm for a new intellectual commons." Software
Freedom Conservancy. Law of the Commons Conference, Seattle University. 10 May
2009. 9 Apr. 2010 <www.youtube.com/watch?v=tbcy_ZxXLl8>.
Moradi, Iman. “Glitch Aesthetics.” Diss. University of Huddersfield, 2004.
Pold, Soren. "Interface Realisms: The Interface as Aesthetic Form." Postmodern Culture 15.2
(2005) Project MUSE. RMIT University, Melbourne, Victoria. 29 Mar. 2010
<http://muse.jhu.edu/>.
Reas, Casey. "Software Structures by Casey Reas et al." Whitney ARTPORT: The Whitney
Museum Portal to Net Art. 3 June 2004. 16 May 2010
<http://artport.whitney.org/commissions/softwarestructures/text.html>.
Runme.org - say it with software art. Ed. Amy Alexander, Olga Goriunova, Alex McLean and
Alexei Shulgin. Jan. 2003. 30 Mar 2010 <http://runme.org/>.
Ward, Adrian. Auto-Illustrator. Computer software. Vers. 1.2.038-CarbonPPC. 2000. 9 May
2010.
Young, R. “Worship the Glitch: Digital Music, Electronic Disturbance.” Undercurrents: The
hidden wiring of modern music. Ed. R. Young. London: Continuum, 1999.
Tom Jeffreys
2016