What do you see as the relationship between critical code studies and platform studies as approaches to understanding digital artifacts?
These approaches are tightly intertwined. On the one hand, you can talk about code independent of platform. That happens in computer science classes all the time. However, if you take the example of a forthcoming book project, you will see how platform plays a key role or rather how the code can point to an understanding of the platform. Over the past year, I have been working on a book under contract with MIT to analyze a single line of code, 10 PRINT CHR$(205.5+RND(1)); : GOTO 10. This line of code generates an image that resembles a maze. I should say, rather, that the code generates this image when executed on a Commodore 64 because in addition to using BASIC, which came installed on C64s, it also uses a custom set of ASCII code called PETSCII, which included two characters (2 diagonal lines), to create this image. Our exploration of this code, then, has led us to discuss the platform and its context. So to talk about the code is not to exclude a discussion of the platform, hardware, or larger systems, but rather to use the code as the central axis.
Currently, the various approaches to digital objects are associated with specific critics, projects, and publishing series. As a result, “Software Studies” and “Platform Studies” will be defined by the kinds of things these critics publish, the kinds of readings they perform, and their own theoretical predilections. Comparing these first readings could skew the way the approaches are perceived. Taking the long view, I believe these terms will eventually become abstracted from the readings of those particular critics and will become part of rich assemblages of approaches to digital objects that look at the software, at the platform, at the hardware, and, of course, at the code.
What has been the response of programmers to the kinds of work you are doing?
Many of the people who do CCS readings are programmers, so I would say on the whole it has been very positive. You know, there are a lot of misconceptions about what humanities people do, particularly regarding interpretation. When I first began suggesting this idea to professional programmers some voiced skepticism because they thought I was advocating treating their code like poetry. They doubted such a study would yield very much. Once I explained that I was interested in, for example, why programmers chose one programming paradigm over another, their process of writing the code, or even why they were laughing when I would show them some code written by someone else, what was the joke – they started to get more of a sense of what I was after. Once we reach that understanding, they typically offer their own critical observations, reflections they’ve formulated but haven’t had an opportunity to discuss.
You’ve written, “The distance between the Haiku and the can of Coca Cola as texts marks the shift between the study of artistry and the broader study of signification.” So, what does it mean to study code as a kind of “signification”?
Code is a medium of communication, and like other communication substrates, its meaning is not restricted to what its author intended. The way someone writes a line of code, the language they choose, the programming architecture and paradigm, the code they borrow, the libraries they use – all these factors produce meaning in code. That is when code is taken as a sign system with its own material conditions.
At the 2011 CCS Symposium, UCLA Computer Science professor Todd Millstein explained that computer scientists already see code as an aspect of a program that is meant primarily for human readers. It is not, then, heresy to say that code is written for other people to read. By extension, once it is circulated, its meaning expands and changes depending on who is doing the readings. Jeremy Douglass gave a terrific demonstration of this in the second week of the Critical Code Studies Working Group (http://www.electronicbookreview.com/thread/firstperson/recoded), when he showed how two opposing sides of the Climate debate used the source code associated with Climategate to support conflicting points of view.
Code is a semiotic medium. It has rhetoric, style, art. It is a sign of a process and is in-process in terms of its own development. It circulates within discourse realms. It also bears marks of its authorship, signs of communal affiliation, remnants of its history, and notes and stubs for future development. Code has a special relation to the computational system in which it circulates. To make a legitimate utterance with code, one must comply with and conform to many restrictions that do not exist in, say, spoken language. Moreover, code is typically part of a chain of command, a layer of information represented in a form more easy for humans to read than machine language and binary (though my electrical engineering wife does tell binary jokes). Yet, as Wendy Chun has observed, source code is not the same as the executed code.
To explore the significance of code, though, as you suggested, is not merely to look at what it says but to delve deeply into what it does and how it does it. While the signs themselves can produce meaning, for example in their relationship to natural language constructs (Print, function, if, then, void) as well as in comments and variable names, by constituting the algorithms of the program, the code also represents the logic of the program. Here too lies significance in a way analogous to but not exactly like other sign systems. Discovering the particularities of how code signifies is one of the chief challenges of CCS.
What kinds of work do you see your center contributing to the growth of Critical Code Studies?
The HaCCS Lab has two chief goals: to develop and promote the methodologies of Critical Code Studies and to foster dialogue between computer science and humanities scholars. This summer we hosted our first conference and have several events planned for the coming academic year geared toward bringing a diverse array of scholars together. Also, in the Spring, we plan to host another online forum, the third in three years. More importantly, the lab will serve as a hub for scholars interested in working on CCS, a source for news on the latest publications, and perhaps even a venue for provocations in the current debates surrounding code. We are currently investigating publication venues and are examining opportunities to create new courses and to offer workshops for those interested in joining our broader research community.
Mark Marino is the Director of the newly launched Humanities and Critical Code Studies (HaCCS) Lab at USC, named for a field he initiated in 2006. He is the Director of Communication for the Electronic Literature Organization (http://eliterature.org), as well as a writer and critic of experimental interactive forms, including “a show of hands” (http://hands.literatronica.net) and the LA Flood Project. He blogs at Writer Response Theory and is Editor of Bunk Magazine, an online humor zine. He currently teaches for the Writing Program at USC. He is currently working on two collaborative book projects using CCS methodologies. His portfolio can be found here.