Critical Code Studies Conference - Week One Discussion

Critical Code Studies Conference - Week One Discussion

Mark C. Marino

What does it mean to apply a “critical” lens to programming code? Members of the CCS Working Group grapple with this and other foundational questions, hashing out the methods, boundaries, and stakes of a new academic field. This essay is part of a series on Critical Code Studies distilled from a six week online discussion.

Ryan Brooks:

This essay is part of a series on Critical Code Studies distilled from a six week online discussion. As each week is published on ebr, it will be indexed here.
Week 1:
Introduction by Mark Marino

Ryan Brooks:

Mark C. Marino’s talk at the 2009 Digital Arts Conference will be published in a forthcoming edition of Leonardo Electronic Almanac.

Ryan Brooks:

The claim seems to be that the worm reproduces the heteronormativity of tennis marketing, no matter the gender, orientation, or motive of the coder or clicker (a qualification that is teased out later in the discussion). The critical point seems to be that the code is an INSTANCE of and/or (not sure which) a FIGURE for heteronormativity. But don’t both ways to read this critical point make the actual code irrelevant? If this is heteronormative interpellation at work, why do you need to understand code to understand that?


Editor’s note: We are pleased to present a distilled version of the lively discussion that took place in the summer of 2010 at the Critical Code Studies Working Group. Mark Marino, the organizing chair of the group, has written an introductory essay to these discussions and Critical Code Studies as a whole. The text below is drawn from Week 1’s discussion, led by Mark Marino. A video introduction and overview from Marino is also available here. - Ed Finn

It is my distinct honor to welcome you to the Critical Code Studies Working Group.

What started as an idea about the need for a kind of seminar to produce readings of code has turned into something much, much more.

Just take a look at the names of those gathered here and you will see a veritable who’s who of techno-culture studies and no doubt the who’s next of code studies.

I thank you all for coming and I promise you that this will be time well spent. Special thanks to my coordinating assistant Max Feinstein and to Jeremy Douglass and Dave Parry who helped develop the shape of this working group.

For agreeing to publish these threads, I would like to thank electronic book review, particularly for the generosity of Joseph Tabbi, and editors Lori Emerson, Ben Robertson, and Ed Finn.

Critical Code Studies starts here.

In the past 3 years, since electronic book review published “Critical Code Studies” and my talk at the Modern Language Association meeting which named a practice that was already underway, I have watched the flurry of activity in code analysis and software studies with a mixture of growing excitement and vague disappointment. Excitement because the amount of interest in reading code, in examining these world-shaping and world-simulating lines of instructions, has been overwhelming. There have been books, articles, panels, and entire conferences themed around “code” including groups such as SLSA, Digital Humanities, and DAC. The numbers of critics turning their attention to code are swelling, and the movement to instill code literacy in all learners continues to build momentum. There are 17 scholars who are members of the Critical Code Studies blog and another 25 scholars I have identified as prominent participants, but that number far underestimates the number of techno-culture critics who are beginning to count code among their objects of study. We see that in monographs, courses, and even blogs.

However, in spite of my excitement my disappoint remains because as I look at the many articles and books, PowerPoint slides, and blogs that do talk about software and programming, the lines of code that appear in these discussions are precious few and their role in the argument is often minimal, a mere passing example, an illustration that the software does in fact have code. The code often stands in as a sign that there is code in the software. So that brings me to this working group, which aims to build on the original call to action with examples and tools for reading code. It’s time for the full launch of Critical Code Studies.

To jump start that process, to give it a bit of stimulus and some shovel-ready projects, we have convened this working group.

However, while we have many interests and there are many levels of criticism that are worthy of attention, the focus of this working group is the interpretation of computer source code. It is not to speak in the abstract about the nature of code, though we will do that. It is not to speak about the viability of the practice that shall be demonstrated by our readings. It is instead an opportunity, in the context of a talented and committed set of peers, to generate close readings of source code.

In my talk at DAC 2009, I said if you want to do code studies, put more code in your slides. I will encourage us at every turn to put code in our dialogue here. Like the shepherd dog Intro to Literature teacher, I will work to keep returning us to the text.

This is not to criticize those who talk about code in the abstract. That is a fundamental conversation that needs to be fully thought out. There is now a robust body of discourse about the nature of code, how code differs from text and human, spoken languages. People have captured the nuances in the general. But let us table that conversation for another day.

What we need is for someone to show us what you can do with a “goto” statement, as Wendy Chun has. We need to spelunk (or “cave”) the lines of William Crowther’s Cave adventure as Dennis Jerz has. We need to talk Tim Toady like Stephen Ramsay. We need to seek out the little crucial portions of code that Jeremy Douglass calls “snippets.” We need to delve into the nature of networks with Wendy Chun. We need to dwell in coding language as Mez has.

One example calls forth many more. A few years ago, several critics and I performed readings of “Hello, World,” that first program that computer language learners write. Since then, I have seen many more readings of this program. “Hello, World” has become the “Hello, World” of Critical Code Studies. I’ve now seen readings of that in at least five articles and even more presentations that treat upon that program genre.

All digital humanists and cyber-cultural theorists seem to need is an illustration of a reading of a program, and they quickly follow with their own readings. This working group will produce those models.

The assembled group

Who are we? Well, what started out as a modest little working group has become a veritable Who’s Who of techno-culture studies. When I saw the sheer numbers of respondents, I had one thought: I’ve got to order more food.

Members range from those who write about techno-culture to those who have worked in the trenches creating it. Some labor in libraries of text, others libraries of code. Some teach, some take, some create, some disrupt The department affiliations range from English to Art History, Poly Sci, and the many forms of digital culture. Collectively, we know C, Perl, Visual Basic, JavaScript, Java, Fortran and many more languages.

But perhaps what’s more important than the names gathered are the topics: The objects of study include: DamBurst, Google Earth, Second Life, database management systems, semantic web, visual programming languages, live coding, viruses, statistical programming languages, interactive fiction, electronic poetry, and the list goes on.

One group from USC is here as they develop the Magic project, a system for multimedia annotations of source code. No doubt this would be a useful tool in our project.

Throughout the emails of inquiry, I have heard several phrases repeated. Among them:

  • I’ve been doing this for years and didn’t know this was a field of study.
  • I know how to program, I know theory, and now I’d like to know how to put them together.
  • I don’t know how to program but I comment on techno-culture and want to add code to my objects of study.

What is the emphasis?

As I look over the applications and emails of inquiry, I do see a number of higher level conversations rising to the top as in a bubble sort. And despite my note of caution about the pitfalls of discussing code only in the abstract, it will be worth our time to recognize them here.

Among these are:

authorship/authorial intent
the role of code and subject groups
the relationship of code to realism
the role of code in political or governmental systems
the place of hacker code
the examination of code as collaborative construction

No doubt, many other topics will emerge over the course of the six weeks.

What makes Critical Code Studies different?

Much has been made lately about the sharks-vs.-jets territorial border disputes about the interlocking yet distinct areas of study that include: software studies, platform studies, hardware studies and, of course, Critical Code Studies. Critics are right to identify some territory-marking that is typical of canines and geeks.

I do not doubt that we are working on the same material and we waste our time to raise our flags to claim the coffee shop for our own private fiefdom. The coffee shop belongs to, well, caffeine. Our shared fascination with technology will keep us there, talking late in the evening and early morning hours. Nor do I think it behooves us to create sub-category specific jargon. We humanities geeks need all the friends we can get. That’s why we love Facebook.

However, when people ask me why I keep calling for Critical Code Studies and don’t just fold it entirely into another larger field I say, I’ll leave the taxonomy to the taxidermists. But until there is an extensive body of humanities-style readings of source code, it helps to have energy specifically applied to that task. As I mentioned, one reading gives rise to a network.

How do I do it?

When I originally conceived of this group, I wanted to put together a seminar. Since then, the group was joined by the people who have taught me, the people whom I read, the bibliography of the original article. So I’m not going to spend time on the many lesson plans I had developed. At least, I’ll put away my worksheets for now.

But I do want to share some thoughts on technique, since this group will be a lot about practice.

What code to pick?

People, primarily computer scientists, ask me, what is there to interpret about code? Some have asked, what do you interpret when you are facing thousands of lines of code?

This is a valuable question that Jeremy will address more extensively in Week 2.

But allow me to offer my approach.

When looking for lines of code to discuss in an article, I continually ask myself: what is the line or section of code that defines this piece of software in relation to the particular social critique I am working on?

And here I must again add that my version of Critical Code Studies has always, at its foreground and background, the social. To study code is not to flee the world of globalization, economic inequality, participation gaps or issues of race, gender, or sexuality.

What line or lines of this code says the most about the way it operates on people, on culture - even if through processing data or interacting with all systems?

Let me provide a concrete example.

In my talk at DAC ‘09, I analyzed, in contrast to a few pieces of software art, a computer worm called annakournikova.

You may recall at some point receiving an email offering you a picture of the tennis ingénue, whom I have now come to know as a kind of trademark product bought and sold in professional tennis. If you received that email in 2001, you were most likely receiving not pictures, but a worm.

The worm operates by opening up a visual basic script file that grabs your address book and send out messages to your unsuspecting contacts. But you have to open first the file, an attachment, which you might think is a jpg file if you don’t notice (or can’t see displayed) the vbs appended to the end.

My reading was pursuing a question of the heteronormativity of code, an idea raised in Zach Blas’ Transcoder SDK and anti-programming language. (Descriptions available here, here, and for code libraries here.)

My sense was that heteronormativity was something that, like so many other normalizing forces, replicated itself through tacit acceptance, by rendering itself as always already, and by hailing people into a system without making its operation or tenets explicit.

This heteronormativity operated within the bounds of professional tennis and professional modeling, selling the spectacle of high octane young women locked in the perilous volley of a clay court fashion show. When the covers of the sports magazine and the men’s magazine (which at times are the same thing) share the same image, a notion of gendered sexual roles has been deployed. This could be called heteronormativity.

But where was this in the code of the worm? See ‘Appendix A’ at the bottom of this post.. Which lines of this code are worth commenting on?

First of all, this code had to be decrypted, using a simple caeser shift +2.

I focused my attention on this section:

Set thisScript =

FileSystemObject.opentextfile (wscript.scriptfullname, a)

thisScriptText = thisScript.readall

Set newFile = FileSystemObject.createtextfile (wscript.scriptfullname, true)

newFile.write thisScriptText

This most “wormy moment,” as I call it in the article, marks the moment when the worm writes its own contents into a new file. It sets a variable thisScript when it calls the function opentextfile. Then it writes the contents it has read (its own code) into a new file.

Here was the operation of heteronormativity, writing itself into a person’s value system by reproducing its contents in the mind of the person who accepts its deceptive hail, who is seduced into opening the file.

In this context, don’t the various natural language affinities just pop out?

Script. (Here thinking of not just the scripts we read as the scripts - or instructions - computers and humans follow). Writing this ScriptText (composition has been automated here and it’s predicated on copying). Creating a text file (the act of creation of something that is a copy of a copy that will render itself within the system. That this script text will be filled by a call to read all of this script.)

By the way, I have spoken with Chandler McWilliams about the sheer force of reading code aloud with students; it is very much like poetry in that at times, reading the line renders meaning that might not be apparent in the symbols. There is a line of Julie Levin Russo’s code work piece that says:

$humanform->template->assign($body == 'identity' ? 'gender' : $body, $desire);

for the template of the variable humanform, assign the variable body gender if identity is true, but otherwise assign it merely the value of the variable body. And send variable desire while you are at it.

Of course, her work is a piece of code art. But even in the case of the worm code, it helps to read those lines aloud and to say what the operations are: assignment, evaluation, declarations, calls to function.

It is what the programmer must do in her head when she is reading those lines.

But wait, this worm was not handwritten by any programmer; it was written by another program. That’s what we find out from the graffiti style tag in the word of the worm:

'Vbswg 1.50b

So what happens in our conversations about intentionality? What happens to meaning?

The meaning isn’t there because someone hand-chose each line of code any more than the meaning of a building is there because the architect chose every nail or the author of a tract chose her own type font. But once those nails are there….

Meaning is a product of circulation through society and no doubt meaning is what the critic produces, not out of thin air as the skeptical freshman complains when he receives a C+ on his paper on Moby Dick, but out of the discourse networks of signification that surround all of these cultural texts.

Reply by Micha Cárdenas / Azdel Slade on February 1, 2010 at 1:14pm

Part of my intervention here is to do what I’ve learned from Avital Ronell, in her seminar on Lacan’s purloined letter, that is to ask what is here that we can’t see because it’s staring us in the face. But also, preparing for this workshop I’ve been reading Ricardo Dominguez’s references to code, and one of those is:

“For the hacker community, EDT [Electronic Disturbance Theater]’s gestures create awareness that something outside of code is relevant. For hackers this was simply not a matter of concern, as is the case for many actors who are only interested in the formal aspects of theatre and its particular history. Suddenly, with a FloodNet action, they face a code that simulates code and pushes code toward real structural inadequacies that cannot be resolved by code.” - “On-Line Simulations/Real-Life Politics, Ricardo Dominguez Interviewed by Coco Fusco.”

And that brings me to my desire to think about this code in a way that asks what is outside of the code. Specifically, I’m interested in how the code is executed, when it gets run. So I’m particularly interested in these lines:

newItem.Body="Hi:" & vbcrlf & "Check This!" & vbcrlf & " "
set attachments = newItem.Attachmentsattachments.
Add FileSystemObject.GetSpecialFolder(0) & "\AnnaKournikova.jpg.vbs"

This is where Anna Kournikova comes in and is where the link in the email message that is sent out is created. So the author of this virus is counting on someone to click this link in this email who is interested in seeing a .jpg file of Anna Kournikova. I would argue that the author is counting on a widespread sexual desire among computer users which is either male and heterosexual or lesbian to literally drive the virus, propagate it, ejaculate it. Given the widespread infection of this virus, I think we can say that the author’s assumptions were correct. Yet this is not to oversimplify the matter, but to consider the ways in which the operative mechanism of the code is structured by a kind of digital sex culture of the Internet.

Further, to avoid oversimplification, if we consider the lesbian user who clicks on the Anna Kournikova.jpg.vbs link erroneously, perhaps in Outlook on her office PC, we can consider the complexity of emotions she may feel, including desire, but also fear of discovery, concerns about surveillance and possible legal and economic ramifications for her click which are then literally multiplied by the replication and spreading of the virus. As soon as we consider the desire embodied in the click, we can also consider the complex interplay of public and private that are revealed by the operation of the virus, the ownership of the computer and the networked nature of email.

But to return to the code itself, I was also struck by these lines:

Set newFile=
FileSystemObject.createtextfile(wscript.scriptfullname, True)
newFile.write thisScriptText

where the virus replicates itself. If we consider a rewrite of this code into a more literal pseudo-code and substitute the string value in, it could read like this:

Open AnnaKournikova
Insert myself into AnnaKournikova

Here, with a kind of loose (but also close) reading, one can read the author’s desire again, possibly, and understand another possible reason for the naming of the virus as such. This leads me to recent writings by Galloway on interface and World of Warcraft. In the essay “The Unworkable Interface” Galloway proposes an idea of intraface, saying:

the intraface, that is, an interface internal to the interface…the implicit presence of the outside within the inside. And, again to be unambiguous, “outside” means something quite specific: the social… [WoW] firmly delivers an avant-garde lesson in politics. At root, the game is not simply a fantasy landscape of dragons and epic weapons but a factory floor, an information-age sweat shop, custom tailored in every detail for cerative ludic labor.

To conclude, my intervention here, which I will elaborate more later looking at my own code from technésexual, is to say that part of the Critical in Critical Code Studies, for me, has to look at the preconditions and outside forces which shape the code and shape us and our analysis of the code when we come into contact with it, but also to consider that any naive seeking for an outside quickly reveals that the outside and inside are mixed, enfolded, inseparable.

Reply by José Carlos Silvestre on February 1, 2010 at 2:59pm

I am not sure about much of the “gendered code” discussion. For instance, when Mark states:

My sense was that heteronormativity was something that, like so many other normalizing forces, replicated itself through tacit acceptance, by rendering itself as always already, and by hailing people into a system without making its operation or tenets explicit.

One could argue instead that heteronormativity is positively enforced, and then erases its own history “in order to believe in itself,” rather than actually propagating itself tacitly, as part of an Already-There. I was also quite surprised to find Micha reading self-replication as masculine in nature; why shouldn’t we understand self-replication as female instead, the phallic suggestions of “writing” (that is lost in the digital, where it is in any case always already a metaphor) notwithstanding?

But I’d like to draw attention to another aspect of the Anna Kournikova worm. Self-replication was not new, of course; the worm’s success rested instead on another realization of the potentiality of malicious programming, namely, a confusion between a file of (inert) data and an executable file, and of how the operating system distinguishes and represents both. A related device is found in other malicious applications which use overflows in data files to write arbitrary executable code. The fundamental security violation here occurs in what’s perhaps the most basic abstraction of programming, that which separates strings of bits into “code” and “data.” It is a pity that the programmer was not capricious enough to have the code also display a picture of Anna Kournikova, and extend this violation to the user’s experience rather than restricting oneself to the OS’s flawed representation thereof. This clever hack, moreover, mirrors that of self-replication, which travels the other way around: code manipulating itself as data behind the user interface. And so on.

Reply by Mark Marino on February 1, 2010 at 9:47pm


I find your point about the slippage between code and data, or the mis-identification (by the user) to be particularly useful here.

But I would like to hear more about this line:

It is a pity that the programmer was not capricious enough to have the code also display a picture of Anna Kournikova, and extend this violation to the user’s experience rather than restricting oneself to the OS’s flawed representation thereof.

For me, the fact that the worm does not deliver hearkens back to what has been said about pornography: “to the extent that an ‘imperative’ is depicted and not ‘delivered,’ it fails to wield the power to construct (unilaterally, exhaustively) the social reality of what a woman is” (Judith Butler, Excitable Speech, 68).

That this worm does not deliver a picture reflects something at the (un)center of the Internet, links forever linking; it is why the search bar is the icon of the age, why more bandwidth does not lead to more satisfying or thoughtful content.

Again, this for me is the act of the normalizing force: a kind of bait and switch that leaves a reminding spot, a remnant of complicity. To return to the argument from my article, even though this is tacit, I don’t see it as any less positive. Just as the role of sexuality is built into many sports, notably tennis.

And lastly: “This clever hack, moreover, mirrors that of self-replication, which travels the other way around: code manipulating itself as data behind the user interface.”

Excellent… and also code programming users to execute.

Reply by Jeremy Douglass on February 2, 2010 at 1:39pm

I like where this is going. To continue considering the JPG (or lack thereof) in the context of Micha’s original “what is outside of the code” point, there is a broader situation for the email reader of relevant personal, social, and software contexts.

One potential context is that the referenced pictures don’t exist, but similar pictures do - the target audience of this worm has been exposed to them, or has reason to believe are available. Can you really understand the code of the virus without understanding why a person would complete the cybernetic feedback loop by activating? In that case, the ideal picture (the “purported” JPG) is motivating, but that motivation arises in part because of real examples of erotic JPGs as they were/are circulating on the Internet and over email in a whole erotic image ecosystem. These images (as much as Anna in her various manifestations) form part of the data that drives the cybernetic system.

This culture of Internet images (and the plausibility of such an image existing and circulating on the Internet) also informs the authoring context - the code couldn’t be written in this way if the coder wasn’t familiar with the effect of the cultural payload.

Many viruses, worms, and hacks rely on social engineering and/or user complicity to complete the circuit - hence the use of terms like “Trojan.” One stance on computer security is to argue that a system is secure as long as you don’t open the gates - that is, no matter how brilliant your worm, you can’t compromise (penetrate, etc.) the system unless someone lets you in.

By the same token, one could argue that Troy was tactically invulnerable, and that the creation and use of the Trojan Horse was not a battle strategy. And yet, Troy fell.

Reply by Mark Marino on February 1, 2010 at 10:01pm


I like your notion “a kind of digital sex culture of the Internet” which evokes for me Michael Heim’s Erotic Ontology of the Internet. I also like your intervention about the full range of users who open that message. No doubt, there are others. I have in my head some trusting user of the Internet, maybe someone who uses it only to pass tales of grandchildren, perhaps using AOL, receiving the message and opening it, with no desire at all. The “why” of the worm’s success is not revealed by its success.

As to your reading:

“Insert myself into AnnaKournikova” is a wonderful reading. We should add this to the methodologies, this “loose (but also close) reading” or this translation into pseudo-code.

You could also read that line as: I will write a new message and fill it with that which will not be named here.

Reply by Gabriel Menotti Gonring on February 1, 2010 at 4:31pm

I wasn’t expecting to see something so close to a critical reading applied to code, but the results look promising! Being the first week, let me play the devil’s advocate and wonder if this methodology cannot lead to the old problem of mistaking code with text, and treating it as a system of metaphors to be interpreted/discourses to be unveiled.

Would it be more productive (or even feasible, given peoples’ backgrounds) to push forward algebraic or mechanistic analysis of what is being enacted by the codework? Instead of interpreting the code-as-text, analyzing the way the machine computes it, and the difference that might exist between these two ‘interpretations’ (reading/enactment)?

After all, those objects, variables and functions have these names because they are mnemonics in the first place - or poetical statements of the programmer that speak directly to us, ‘critical readers’. For the machine, they ‘mean’ nothing.

Even the difference José makes between “(executable) code” and “(inert) data” has no point for the computer. A jpeg code is executable - of course, not by itself. But which piece of software is? The very idea of software is a functional abstraction, given the way logical and physical systems interrelate in computing. Maybe we cannot analyze code without foregrounding the containing platform - the layer in which code is read, compiled, interpreted.

Reply by José Carlos Silvestre on February 1, 2010 at 6:04pm

Menotti: I thoroughly agree with your objection. The Turing Machine does not require an a priori distinction between commands (“executable code” in its basest) and (inert) data, and such distinction is also absent in small-scale integration digital circuits (i.e. logical gates), which are the deep-buried foundation of actual computers. It is for this reason - that this is an abstraction about binary data - that self-replication and Quine programs are possible in the first place. On the other hand, this is a very basic abstraction, since machine code enforces this separation: there are bits reserved for commands, bits reserved to reference registers, etc. And you can’t goof around much with this, because this parsing happens on the hardware level and the processor’s architecture is not itself reprogrammable.

I like your point that a jpeg file is executable in a sense. After all, it is a piece of code that, passed to another program (an image viewer), produces a certain effect - colored pixels on the screen - not unlike an executable file is passed to the OS to produce effects. Here the border becomes fuzzy: what counts as code? I can’t see much of an essentialist difference, and I guess we must rely on situated practices and systemic conventions instead, as usual.

There are two texts that come to mind here that I think would be relevant. One is Kittler’s There is No Software, and the other is the hacker-canonical poem The Story of Mel.

Reply by Mark Marino on February 1, 2010 at 10:19pm

let me play the devil’s advocate and wonder if this methodology cannot lead to the old problem of mistaking code with text, and treating it as a system of metaphors to be interpreted / discourses to be unveiled.

Ah, the devil is in the data.

I have been thinking a lot about this particular objection, since it came out in The Valve and in my conversations. The objection: to treat code as metaphors is a serious error. Such an objection suggests that we could make the exact same argument by substituting “butterflies” or, worse, that any line of code can speak to any process or notion. Or rather because code itself is a mostly arbitrary sign system, that the signs themselves are arbitrary and hence meaningless.

That last claim is an or-gate too far.

I try to avoid that fallacy by examining the way the piece of code speaks to its context of creation, circulation, and operation, reading the code against what it does and how it has or does operate.

But recently I’ve been realizing that code itself is deeply metaphorical. Not to move too far into the world of close reading and literary analysis, I open up my online OED and find:

2) Something regarded as representative or suggestive of something else, esp. as a material emblem of an abstract quality, condition, notion, etc.; a symbol, a token. Freq. with for, of.

and this wonderful quote by Emerson as example 1:

1836 R. W. EMERSON Nature iv. 41 Parts of speech are metaphors because the whole of nature is a metaphor of the human mind.

Code is metaphorical in the sense closer to N. Katherine Hayles’ “material metaphors.” On the one hand, it stands as a proxy between human readers and machine instructions. But on the other hand, it is a sign system that corresponds to another realm of discourse and interaction. It mediates.

Reply by Jennifer Lieberman on March 7, 2010 at 12:38pm

Even I’m suspicious of the interpretive moves I’m going to make here in the name of experimenting with a code hermeneutic. It’s sloppy, because I haven’t fully formulated my thinking about reading code yet - so I would love feedback.

Gabriel, I really liked what you said about wanting to see how the code works- how it is parsed into its various executable forms.

Like Mark, this makes me wonder what we might learn by considering alternative methods that would have the same effects from an end user’s perspective. In other words, I’d like to consider contrasting the syntagmatic (what is actually on the page/screen) with the paradigmatic (the other possibilities or ideas represented by what is not on the page/screen).

I’d like to focus on the mathematical/programming paradigms at play in a program/code excerpt/inert data set (for example, object-oriented versus procedural). I think it is potentially interesting to think about when the code *needs* to switch between paradigms because it might not be possible or feasible to process another way, and when switching between paradigms is more of a stylistic choice.Though, I’d be wary of emphasizing the authors’ intention here, because there are many factors that can go into this kind of authorial decision: maybe the programmer is more familiar with one language than another.

I think in either case, we may learn something nontrivial about how writing (and potentially reading) code involves conceptualizing the content in different ways. I don’t think that there can be any facile interpretive method once we do parse this information out - I would hate for a reading that decries the politics of any object-oriented code because it objectifies language/people/ideas. But, perhaps at this point a literary-critical methodology might be useful in analyzing how each paradigm calls upon the writer (/reader?) to interpret what a program can/should do.

I am curious: what might we gain from thinking about the paradigms used to run a program? Are the assumptions embedded within programming paradigms accessible to the user, as well as the reader/writer? If not, is there anything worth saying about the erasure of the programming paradigm? Just a thought…

Reply by Gabriel Menotti Gonring on February 2, 2010 at 12:48am

Here the border becomes fuzzy: what counts as code? I can’t see much of an essentialist difference, and I guess we must rely on situated practices and systemic conventions instead, as usual.

Word. But we should approach the analysis as situated and bounded by conventions as well. In practice, your rhetorical question is answered by our methodology (“what is our object?” “Our object is what we analyze / can analyze.”), revealing epistemological limits - the same limits that also exist in the practice of coding.

(Slight detour: just as we want to bring code analysis into the humanities, shouldn’t we try to push humanities out of itself?)

Inasmuch as we acknowledge the machine’s (and society’s) other layers, we don’t mess with them (in any sense) - just the ones the code-text, as a description, refers to (heteronormativity, copyright license, etc). The problem might be that this leads to the analysis (and practice) of code as heavily self-contained pieces: if I want my code to be understood/read (by a certain public, in a certain way), I will write it as such - and this is true both for artists making statements and for generous developers that comment their lines throughout, use readable variables, etc. In any case, the critical reader seems to be just discovering the logic behind the coder intentions, as in a whodunit.

(In that sense, an alternative methodology that comes to mind is the judgment of demoscene contests, based on the comparison of the size of different code pieces regarding their output effects.)

Reply by Marisa Leavitt Cohn on February 2, 2010 at 12:14am

“This” is one of those same containers that hails us. It is always already but only because we take our desire as the agentic act, witholding desire and witholding the mouse-click as a non-action. We fall into the enframement of operational language when we do this. All the “reply to this” links on this page I did not click. Are they omissions, executions of choice, preference, votes of confidence in the meritocracy of ideas? The only way for me to participate in this conversation is to click and then to click some more. Am I being disciplined as a code scholar in this way?

I have no problem with close readings of code but I feel like the code snippet as an object and this fill-in text box are not such different animals. As pointed out by Gabriel, the calling out of any layer to read and interpret it is a kind of foregrounding. Why does the code snippet get to be actual code and the box not? They are both material metaphors… no?

The pseudo-code translation:
I will write a new message and fill it with that which will not be named here suggests exactly that, that the box which defines a message but has no message in it, or contains within it the scandalous non-message as the power behind all messages, is a kind of code.

This reminds me of work by Dina Friis Toft (Users as a Resource, Proceedings of 4S, 2009) on viral videos and how the unfolding narrative of a hoax being revealed as hoax is only received well by its audience when it provides a hint of its own wrapping - a way of looking for the answer as already contained in the message. We have already raised the idea that heteronormativity as expressed in the AK worm is rendered as always already. The form of code seems to be one of always already, so long as we are hailed into the operation. The always-already-ness depends upon the mouse-click which is itself another always already. The status as always already is one that rests in the case of the AK worm on the mouse-click as always already performed. Why does the mouse click, which may or may not occur, get presumed? Isn’t this interpretation an effect of the worm in that it hails forth an impotent mouse-click, an action as non-action? We are perhaps conflating this impotence with the status of always already. The user who withholds the mouse-click undoes the always already status of the worm, and this withholding is in a way an act of resistance?

“Here the border becomes fuzzy? What counts as code?”

Does the mouse-click count as code? If our methods are to use the “context of creation, circulation, and operation” as the means for interpreting a line of code, then does the mouse-click get interpreted as contextual? When is the click the context and when is it an execution? The distance between the click and the code is perhaps the distance being replicated by the worm. The fact that the click is in an ambiguous status as execution/non-execution is perhaps exactly the script being played out again and again. How does the click count? On a website visitor count, on a banner ad click-through. When are mouse clicks counted and how are they counted? I think that the “click now and get some object of desire” is an instantiation of the question when does the click count? And the answer is a kind of yes of diminishing returns perhaps.

Material metaphors not only stand as a proxy, but make us all into proxies - the programmer and the user. The mouse is not a proxy finger but the finger is a proxy mouse or now with touch pads the finger is a proxy finger. Perhaps the AK worm program is a reading of the mouse-click? Rather than treating the mouse-click as an effect of code we might see it as a kind of code. We allow for get statements that fill in words to make up the pseudo-code that we interpret, so why not include the clicks, the enactments or performances by the user as part of the pseudo-code we interpret rather than as its context or periphery? Why not see the AK worm as a critical reading of the code “click”? We are attributing the always already to the image of a woman, but what about the always already of the click itself - a kind of embodiment of always-alreadyness?

I am an anthropologist by training, so please discipline me if I commit close reading sins.

Reply by Mark Marino on February 5, 2010 at 9:37pm

Wow, Marisa,

Thank you so much for this comment. I’m going to underscore a few lines:

Material metaphors not only stand as a proxy, but make us all into proxies - the programmer and the user.

Does the mouse-click count as code?

I like this question of where the code ends. Mouse-clicks are events, right programmers?

But I think your challenge to the ontology of code offers opportunities for a more nuanced understanding, one that others have gotten into when they say the code of the worm is actually functioning within the software insecurities the worm plays on, a Latourian move to see the networks of code at work and the ways one piece of code is never bounded by the software that contains it.

Question: Are there other places in this worm’s code or operation where we see traces of the other code with which it operates?

I also like that we may have to build CCS not around the notion of source code in isolation, but a set of programs operating together. What are all the programs referenced in AK?

My questions here pursue a line of reasoning raised here by Jeremy.

Reply by Stephen Ramsay on February 1, 2010 at 9:20pm

Self-replication (and the attendant phenomenon of indirect self reference) is hardly the only way to be destructive with code. In fact, considered simply as a way of taking down a computer, it’s rather like the movie assassin, who, inexplicably, chooses to inflict a long speech upon his victim instead of killing him silently in his sleep.

But the quine is a game and a trick - a form of textual misrule. It’s the grain of wheat at a1 that ends up being 18,446,744,073,709,551,615 grains on g8. It’s the gremlin that decides to take a dip in the pool.

I have never known exactly which side to be on when it comes to comparing code to text (I’m distressed to hear one poster above refer to this as a settled question). I want to continue to withhold judgment on that, though to be honest, it reminds me of similar canards that appear in other discussions (like whether one can do literary critical analysis with computer games - as if a theoretical observation could ever act as an enforceable prohibition). And my ambivalence is handy here, because I want to say (following Mark) that this code structure is not created by the exigencies of engineering, but by the rhetorical need for an inside that resembles the outside.

Reply by Micha Cárdenas / Azdel Slade on February 1, 2010 at 11:10pm

And my ambivalence is handy here, because I want to say (following Mark) that this code structure is not created by the exigencies of engineering, but by the rhetorical need for an inside that resembles the outside.

I wonder if this is something fundamental about Critical Code Studies or Software Studies, a desire to be inside [the machine], or to get closer to the inside, or to get at “what’s really going on”. It parallels, for me, the way that performance art was a way at getting closer to the real, the real body of the artist, a real “live” exchange between audience and artist. It feels like there is some kind of desire in Critical Code Studies to say that by looking at the code, we can understand more clearly what the operation of contemporary society is, because so much of contemporary society “runs on code.” And yet my desire is still to see what is outside of the code, what escapes the rhetoric of executable code, error conditions, presumptions, rebellious processes (and here perhaps I think of the code as a body the way my own body refuses to comply with the mythopoetic rules of society), the outside within the inside and the outside that structures the inside.

My own artistic practice tries to use code in a way that invites an audience into a moment which is unquantifiable, to use a digitally codified representation of analog signals to enact a certain affect. Here again, for the bibliography, I refer back to the cyberfeminists and their poems, such as in the book Cyberfeminism: Next Protocols, which I’ll share a quote from soon.

Reply by Gabriel Menotti Gonring on February 2, 2010 at 1:00am

Once again, I think we are bound by epistemological limits. How can we possibly judge if the inside (of the machine, I suppose) resembles the outside (‘code-as-description’)? The supposed inside is limited by the compiler, an abstract (and arbitrary) interpreter in itself.

Conversely, when reduced to its schematic skeleton, isn’t rhetoric a form of engineering?

Reply by Stephen Ramsay on February 2, 2010 at 7:51am

I love the idea of rhetoric as engineering generally, but I’m particularly drawn to it in this context.

What’s troubling us, I think, is the impression we have that “text” is an infinite field of open-ended signification, while code is tightly constrained, context free, and highly limited. “Look, man, that’s just the way you write a for-loop in VB. Try not to get too carried away.”

But of course, “text” is not an open-ended field of signification. It’s not “anything goes” in contrast to the “only one thing goes” of code. “Rhetoric as engineering” reminds us of that, by emphasizing the way that all writing is writing under constraint and highly embedded. Maybe even, if you’ll pardon me, “compiled.”

It makes me wonder if the patron saint of CCS might be Wittgenstein (as opposed to, say, Deleuze).

At the same time, I also want to quote Micha Cárdenas / Azdel Slade’s sterling phrase above, which I think catches us all out right away:

I wonder if this is something fundamental about Critical Code Studies or Software Studies, a desire to be inside [the machine], or to get closer to the inside, or to get at “what’s really going on.”

CCS certainly has this razor sharp rhetorical tool at the ready. “Ah, idiot lecteur…what you’re looking at is the outward illusion. Inside, we can see what’s really going on.” But then, two things about that:

1. That might be the fundamental rhetorical move of criticism as such.

2. Mark is trying his damndest not to do that.

Reply by Jeremy Hunsinger on February 6, 2010 at 9:57am

Technically we have two sets of measures of the inside of the machine. There is the grey literature, which describes the machine, and I include internal documentation and environment variables here. Those define what the state of the machine is supposed to be. However programmes and systems administrators also have a set of tools to explore the machine that allows us to find where the machine might be slightly different and how to account for that: perhaps one of the processor pipes or the memory has an error, etc. In short, there are some ways to find some things out about what we can ‘know’ about the ‘machine.’ That said, it is possible, as the code we were talking about seems to indicate, that elements can be occluded from the possibility of knowing.

Of course, most of that has no real connection to how and why code works in most normal conditions.

Reply by Jeremy Hunsinger on February 6, 2010 at 9:47am

I don’t see why code as text can’t be settled in one community and not settled in a plurality of others, or its inverse. That’s sort of the way that knowledge works… different communities can hold different axiomatic and different axiological systems, operating completely differently, yet still everyone is producing knowledge though holding different beliefs about that knowledge. There is no necessity for the old ‘unity of knowledge,’ ‘everyone must agree,’ or ‘everyone cannot hold contradictory beliefs’ constructs of modernity unless of course that is the game we are playing.

Reply by Barbara Hui on February 2, 2010 at 4:53pm

I wonder if this is something fundamental about Critical Code Studies or Software Studies, is a desire to be inside [the machine], or to get closer to the inside, or to get at “what’s really going on.”

Hm, well maybe it’s not so much a “desire” as the recognition that there’s a difference between “close reading” text (or code as text) on the one hand, and paying close attention to the way in which software (as a package) exists/runs in a social context on the other? Forgive if I’m being a n00b here, but maybe there’s a problem with the name “Code Studies”? “Software Studies” seems to be a better name for what Mark and Micha are doing, for example, because it implies attention to the “outside” rather than to what the lines of code themselves are doing - and there is a qualitative/epistemological difference between software as it is interacted with by humans vs. how it is interacted with by machines, no? (I suspect I’m stating something that’s been stated many times before here).

What confuses me about CCS so far is that it seems to want to do several things, each of which I view with various degrees of curiosity, suspicion and interest. The thing I’m most ambivalent about is the move to read lines of code as text, i.e. computer code as a sort of poetry or metaphor. This just strikes me as a bit silly and ultimately open to any interpretation you could possibly imagine, although I freely admit that might just be the skeptical coder in me not being open-minded enough. Still, as somebody who writes code for a living (and also for use by humanities scholars), the idea of taking the code I wrote today (or any day) and close reading it in the way one reads poetry or literature seems pointless and absurd (being blunt here to make the point, of course).

Now, it seems to me that what Mark and Micha are doing, for example, is saying something more interesting than this about the “code” - but in order to do so, they make the move of abstracting the “code” away from its executable/utilitarian/functional context so that it becomes text. Mark, for example, brings in the example of TransCoder and SlashGoggles, both of which are not actual code in the sense of being executable, but rather texts posing as computer code via the use of code-like syntax. Both of these examples are brilliant parodies of and commentaries on computer culture, but don’t really help us to read code itself in its originary context.

Of course Micha (and Marisa with her desire to bring the mouse-click into the discussion) want to discuss the social context of the software that’s created by the lines of code, and this is a rich approach, especially because current software is interactive and involves feedback loops. But again, we’ve moved away from the code and towards the software (as a larger ‘package’ or entity?), which is all interesting and good, but not “code” studies. Is it?

Reply by José Carlos Silvestre on February 2, 2010 at 6:00pm

but in order to do so, they make the move of abstracting the “code” away from its executable/utilitarian/functional context so that it becomes text.

Very well-put. This is what I was calling, borrowing from Pias, “hermeneutics forgetful-of-technics.” Not something to be discarded, but very dangerous indeed.

Source code is supposed to be read, and you can tell a good programmer by the clarity and readability of his code. Code has its own conventions about how one goes about reading it, though, and these conventions guide how code is written and how programming languages and environments are engineered. OOP, for example, doesn’t do much for performance - with all its added overhead and whatnot - but has become a leading paradigm because of its modularity and readability: that is to say, because it is, in some sense, intuitive for a programmer and adequate for the demands programmers face in practice (for instance, of constantly editing code for slightly different purposes). These conventions, and the possible justifications thereof (such as being intuitive and adequate for common purposes), still lack, [as far as I know], a thorough critical study.

This point in which code is read, and supposed to be readable, is where code borrows from text and becomes a sort of hybrid, and this, along with the “software studies” dimension you just mentioned, create the possibility for the kind of dangerous reading you and I are alerting people about, and maybe even the necessity that code be also read as one commonly reads text. The enterprise is still a cart ahead of its horse, though, until a better understanding of code as it is commonly read and practiced is sedimented.

I find the discussion has taken two different paths, which often meet in the same posts: one is the gendered, forgetful-of-technics reading that takes code loosely as though it were text, and the other is a more conceptual concern about the very limits of code. Gabriel cleverly pointed out that the border between data and code is blurry and possibly arbitrary; Marisa blurred another border, that between the activity of the programmer and the interaction of the user. Another, more radical blurring is suggested when Mark spoke of the code “programming the user to click”, and Gabriel and Stephen entertained the notion of rhetoric as engineering: there is a bold, Kittleresque leap in there, extending programming - if not coding - beyond the programming of digital machines.

Reply by Barbara Hui on February 2, 2010 at 6:40pm

All great points here, José. I wonder, partly to play devil’s advocate but also partly in all seriousness, if it shouldn’t be incumbent on practitioners of CCS to also be skilled/experienced writers of functional code? Just wondering this because it tends to be the programmers who raise the sorts of red/yellow flags that we’ve raised. Meanwhile, non-coders are happy to abstract code and practice hermeneutics forgetful-of-technics. I remember somebody at DAC calling the objection we’re raising “the programmers’ objection.”

It’s just that, as a programmer, you look at code and read it in a functional/utilitarian/executable way, while I imagine that somebody who’s not a coder reads it as text. Those two people will come away with two fundamentally different readings of the same “code.”

Reply by José Carlos Silvestre on February 3, 2010 at 4:59pm

Since we are going into the “author’s subconscious desire” here, I think it is important to remember that the author of the AK Worm, Jan de Wit, did not write the self-replication routine himself, but borrowed it from another programmer, who goes by the nickname [K]Alamar. (Details here)

So, if we are to attempt to reconstruct the origin of the worm, it goes somewhat like this:

1. A generic worm generator is written by [K]Alamar. At this point, there is just an empty field for a filename to be clicked by the user; once this is clicked, the worm replicates and propagates itself. It is difficult to argue for unconscious gendered discourse at this point: self-replication here can just as well be read as “giving birth” to another similar to oneself, but there is little to invite this reading either way. (If, for example, one used the promise of a game of Tetris as bait, which at this point is just as likely, would we have thought of gendering the code at all?)

2. Jan de Wit considers how to get people to click the worm, the key security breach. We can reconstruct this in two steps:

A) It must not look like a worm, it must look harmless. Executable files are dangerous; data files are harmless. So let’s make it look like a data file. This, I insist, is the crucial insight in the creation of this particular worm.

B) It must be something people would be willing to click. So Jan de Wit decides to fill in that generic field (from code he did not write) with a promise of a pornographic picture. This is where concerns about sex and gender become relevant - and do not get me wrong: I do think they are extremely relevant to read the piece of code in question. Would it have been less effective if something else had been chosen? When I check my spam folder at Gmail, I see a lot of similar worms: posing as text files, MS Excel files, and so on. Most often, they pose as personal communication, rather than impersonal file-sharing of pornography or the like. Consider, here, how the I Love You virus or Nigerian scammers trick users.

3. There we go. Send it in to unsuspecting targets.

When we consider this genesis of the worm, the idea that there was a subconscious drive to “write ‘anna kournikova’ and insert ‘myself’ into it” becomes considerably less plausible. There is also the uncompellingly obvious reading of the viral self-replication of an infection that is acquired by sexual conduct, and many other readings that proceed by metaphor.

When you look for “subconscious desires” in the writing of the code, you are talking about symbolic substitutions, which can still be safely called metaphors. And metaphor does not belong to what we could name the “system of code,” that is, coding as it is thought of in computer science: you are reading a textual dimension to code. I know this is a deliberate move (and Pias, in the original context of critical analysis of video-games, also describes Technik-vergessene Hermeneutik as a deliberate forgetfulness). Again, I do not claim that this is irrelevant or futile per se; much to the contrary, I agree with Marino that this kind of reading is necessary. But it is a dangerous way to read code, especially if we do this before we have undertaken more code-ish investigations, such as trying to reconstruct the coding procedures that generated the worm.

Reply by Jeremy Hunsinger on February 6, 2010 at 10:06am

A person who reads early Foucault without having read Borges and Bataille has a totally different experience from a person who has read Borges and Bataille. Some people read Foucault for the limited utilitarian applications also, which I find sad. But code literacy/cultural literacy or just plain literacy in your areas of study has always been a key to understanding. However…so is the element of difference, so a person that is taught to code from an engineering background would be different, as you say above. But then…it is through the understanding of the possibilities of difference that we can really generate interesting insights. So if X reads something as Z, and I read it as V, the interesting part is why X is different from V, and perhaps even why X is the same as V. There is always a plurality of readings; there have been whole disciplines founded and lost on the basis of getting standard readings and/or understandings. Many are still ongoing: hermeneutics, etc. Some are pretty lost, such as Diplomatics, the subfield of Library Science, which sought to in part define the provenance and original readings of documents, or discover it.

Reply by Hugh Cayless on February 2, 2010 at 6:20pm

The thing I’m most ambivalent about is the move to read lines of code as text, i.e. computer code as a sort of poetry or metaphor.

I’m with you on this, Barbara. As someone who spends a lot of time writing code, I think it’s dangerous to project too much meaning onto it. At the same time, I can’t help but feel there’s something to CCS. Programs do have styles, their creators have motivations for writing as they do, and there may be productive ways of reading code that go beyond the purely technical analysis of its function.

I’m a bit skeptical of pulling out bits of code and quoting them for effect, the way one might a line of poetry. It’s utterly unremarkable that a worm opens a file and writes a copy of itself into it when executed. By definition, that’s the sort of thing worms do. What interests me about the Anna Kournikova virus is its ineptitude. It doesn’t attempt to do anything actually malicious, even though it certainly could have. The problems it caused were incidental to its success at replicating itself. The program is a relatively innocent, adolescent effort, made dangerous to mail systems by the author’s hitting on a sexually tempting name for the payload. In this instance, the social aspect is probably the most interesting thing about the code. But I don’t think that’s always necessarily going to be the case.

Reply by Mark Marino on February 3, 2010 at 11:34am

I love it when you say:

The program is a relatively innocent, adolescent effort, made dangerous to mail systems by the author’s hitting on a sexually tempting name for the payload.

What about this specific code reveals it to be an “adolescent effort”? I hear you implying that there is something sophomoric about that act of making the code, but is the code itself somehow adolescent (representative of an immature programmer)? If so, can you point to particular lines? As someone who codes, do you see something in the way the code is structured? Since it was generated by a worm-making program, wouldn’t it almost be an infantile or toddler effort, requiring almost no knowledge of programming?

Reply by Hugh Cayless on February 3, 2010 at 1:26pm

This for starters:

if month (now)=1 and day (now) = 26 then "Http://," 3,false
end if

This is where the virus’ true payload would go, if it had one. The modus operandi of these things being a) propagate as far as you can, b) plant some sort of evil program on the host computer (often set to trigger on a particular date). The code above looks like a fairly dimwitted attempt to figure out how to deploy a malicious payload. But it doesn’t look to me like working code. I’m pleased to say that my VB skills are very rusty, but the condition will only be met if the script is executed on Jan. 26, and I’m not sure if the command within the if block will work. This says that the second argument to the Run method is a command (such as one you’d type into a Windows command line). All there is, is a URL. A more sophisticated virus might download and execute another program, or plant a piece of code and set it to execute at a later date, etc.

So it reads to me like the author doesn’t really understand how this stuff works. I don’t know how much code the generator itself supplied, so it’s a bit hard to gauge the level of skill here, but it’s not high. I say “adolescent” because this is a prank on the intellectual level of toilet-papering someone’s house. What’s interesting about it is the social context, the ease with which it was created, and the way it spread.

I think the code itself is basically junk. That’s an aesthetic as well as a utilitarian judgment. Perhaps the fact that I feel comfortable making such a judgment points to a way forward though. If some code is identifiable as junk, other code must be the opposite. What’s the basis for making that kind of distinction?

Reply by Mark Marino on February 3, 2010 at 1:54pm

Excellent, Hugh, this, what you have done is CCS.

Don’t get me wrong, I don’t seek literary or highly proficient code to read. I don’t see CCS as literature class for Computer Science majors, although some code may be so innovative and profound. I am interested in code objects both mature and immature.

Noting the level of apparent knowledge of the programmer is key, though, because it’s such a big part of the bravado and Perling competition of programmers.

Reply by Micha Cárdenas / Azdel Slade on February 3, 2010 at 5:28pm

Perhaps one of the important parts of CCS is choosing an interesting piece of code to read, which Mark has clearly done here by choosing a virus that works through obfuscation and tricking the user and that so clearly invites transversal lines of analysis including gender, sexuality, interface and authorship.

I wonder about Barbara’s question above in relation to Hugh’s analysis, where she asks “I wonder, partly to play devil’s advocate but also partly in all seriousness, if it shouldn’t be incumbent on practitioners of CCS to also be skilled/experienced writers of functional code?”

It seems very much like asking, can only queer people write queer theory, or can only people who engage in queer practices write queer theory, which seems problematic to me. Although it’s further problematic in this case because there is a history which we have to deal with of people who are male and of European descent being encouraged to study science and technology. Formulating a field like Critical Code Studies might be setting up parameters so that only people who understand code can do it. If that is so, then it would seem to exclude a lot of people along lines of race, class and gender who could have something very valuable to add to the conversation. And yet, a main part of the idea seems to require a proficiency in reading code and understanding how it operates, not just its semantic or linguistic level.

So I don’t have an answer here, I’m just raising concerns, but it seems like there’s an emerging idea here about analyzing code across a number of strata, with as many dimensions as possible perhaps, and finding those places where the dimensions interact, as Mark said ‘when code does what it says’ [to paraphrase] or thinking about the ways in which semantics and operational characteristics interact, such as certain words being chosen for a particular audience of programmers because they make sense to that audience.

Reply by Jonathan Cohn on February 2, 2010 at 6:24pm

Hm, well maybe it’s not so much a “desire” as the recognition that there’s a difference between “close reading” text (or code as text) on the one hand, and paying close attention to the way in which software (as a package) exists/runs in a social context on the other?

Hi, I’m really enjoying everyone’s comments so far. It seems like this question of whether code should be close read really hinges on whether it is considered a type of text or discourse or not. As someone who is relatively new to this, I’m not entirely sure why or if performing a critical code reading can’t work hand in hand with a critique of how it performs when run. I am to a large extent in the camp that says everything should be close read. What I am pondering right now is what kind of information one can gather from a close reading of the code of a program versus a reading of what happens when it is run, or viewed as a compiled program. I pose this question primarily because many of the points I can come to via a close reading of the code are the same ones I would come to by seeing a copy of the email message itself, or of hearing about how it spread itself. The issue of how Anna Kournikova’s appearance in this program relates to online (masturbatory) sexuality can be unpacked in similar ways by looking at the code or the executable program. I am trying to think more about the way jpg works in this situation by to some extent creating a confusion of signs, identity and aura. Like a mirage, it appears to act as an extension of Kournikova the celebrity, but really it seems to refer to a different Kournikova entirely (e.g. the picture vs. the worm script).

if month (now)=1 and day (now) = 26 then "Http://," 3,false

I am really interested in this snippet, to a large extent because it does something that is only perennially visible/accessible/actionable in any form other than by looking at the code itself. The choice of date and website is something of a mystery to me, but it seems to call for a more nationalist type of reading of this code (transnational code studies, perhaps?). While Kournikova is famously Russian, there seems to be some sort of Netherland Pride in this code and it is set in relationship to the online electronics store and to Kournikova herself. Not knowing very much about the Netherlands and its current relationship with Russia, I would love to hear more from others if I am missing or misreading any cultural codes.

Also, I am wondering how the spacing of the code was created, whether by Marino, the code translation program or something else entirely. There is something very poetic about the spacing (which I seem to be failing at adequately recreating) in:


If Not
(FileSystemObject.fileexists (wscript.scriptfullname))
Set newFile=
FileSystemObject.createtextfile(wscript.scriptfullname, True)
newFile.write thisScriptText
End If
Function doMail()
On Error Resume Next

and the last few lines…

End If
End If
end if
End Function

For the programming language to force (or allow) the programmer to have to think about Doing and not doing (as well as fullNames, Texts and truth) in terms of a file’s existence seems to create an interesting nexus of key terms concerning identity and the self in terms of code. This along with the repetitious ending full of deferrals and conditionals (Next, End if) - it all feels very Hamlet to me.

Reply by Barbara Hui on February 2, 2010 at 6:49pm

End If
End If
end if
End Function

It’s funny, but to me this doesn’t read as poetry at all, but instead as the rather badly-formatted endings of several nested “if” statements and a function. I’m bothered that the 2nd-to-last “end if” isn’t capitalized, while the others are, and the fact that they’re not indented is also annoying to me, personally :) I also don’t have any thoughts about “do”-ing in the sense of identity, or existence, but rather in terms of having the computer execute a loop of code statements. I’m more worried about whether the logic and syntax is correct and the end statements line up, etc.

I’m having these reactions because this appears as executable/functional code (that might have to be read/understood by another programmer) to me, whereas I think it appears to you as text, right?

Perhaps programmers acquire a different/additional kind of literacy that is very difficult to ignore once you become fluent in it?

Reply by José Carlos Silvestre on February 2, 2010 at 6:54pm

Perhaps programmers acquire a different/additional kind of literacy that is very difficult to ignore once you become fluent in it?

As though we had been programmed by our coding. I would also like to ask you to share some of your code, if you’d like to: I learned you are interested in geography and mapping (something I have tentatively tinkered with as well recently, but only in very simple, codewise-uninteresting projects) and I think this could be a great place to merge the two strands of reading code. How does one go about organizing a digital environment to map a territory: that is to say, how does one go about creating a map for maps, so to say? The kind of engineering decisions here can lend themselves well to critical study.

Reply by Mark Marino on February 3, 2010 at 11:21am


While I think you are making important interventions, I want to clarify what I mean when I refer to code as a text.

When I say that we should interpret code as text, I do not mean that we need to read source code (only) as strings of characters or a collection of words the way we would read a text, such as a poem, an essay, or a story. In other words we should not read it by ignoring its functionality or its other layers of meaning (semantic, historic, artistic, mathematic).

Instead, I mean that we should read or interpret the code as a cultural object. Here, CCS builds on the work of Cultural Studies, the work of Stuart Hall and others, who opened up our objects of study by critically interpreting visual texts. That together with semiotics opened the way for critiques of the Sony Walkman or even the Bonaventure Hotel.

The characters as words or word-like signifiers are one part of our readings, as data are another, as instructions are another, as ways of manipulating electronic signals another… et cetera.

One more note,

I tend to draw on vocabulary from literary studies: interpretation, close reading, etc.

But when I talk about close reading code like close reading poetry or Moby-Dick, I don’t mean to suggest that code=poetry or that code expressions are written with some kind of poetic ambitions but to say that when we study code, we should deploy the most rigorous examination of the object and all its facets and functions, including the context in which it circulates, and in my training, I have learned that the most exacting standards exist in the context of close reading poetry.

Do other disciplines offer other methodologies we could reference effectively?

Reply by John Bell on February 3, 2010 at 9:06pm

Perhaps programmers acquire a different/additional kind of literacy that is very difficult to ignore once you become fluent in it?

I would agree with that, though I think I would differentiate between syntax literacy and logic literacy. VB isn’t a language I’ve ever used, but I’m still annoyed by the lack of indentation in that code. I’d call that syntax literacy, even though technically it’s not a syntax error since it compiles…maybe the code equivalent of a split infinitive.

I’m more interested in the logic literacy, though. I don’t mean that in terms of all programmers know formal logic, I mean it in the sense that there are structures that - independent of the programming language - programmers use to make things work. How does that literacy change the way a programmer approaches a non-programming problem? Does it matter if they cut their teeth on a procedural language, as opposed to those new kids with their fancy objects and classes? And is there anything in those methods that the non-programmer can apply without ever writing so much as “Hello, world”?

Reply by Mark Marino on February 3, 2010 at 11:44


VB isn’t a language I’ve ever used, but I’m still annoyed by the lack of indentation in that code.

I want to supply you with two useful pieces to consider.

The first are screen shots of the decrypted code as rendered in The Hacker’s Handbook.

The second is a cut-and-paste copy of the encrypted code.

Not sure of this, but I believe the indentation in the handbook was produced by them. The “original” encrypted code has little formatting, but line breaks.

I also post the encrypted version in anticipation of Jeremy Douglass’ talk for Week 2 in which he will consider the particular challenges to choosing and viewing primary sources in CCS. What is the form of the code we should analyze? What are the obstacles to presenting and sharing a text?

As I mention in the article, one of the reasons I chose to read this worm is that it was both generated (in part) by using code-generating software and also because in its (arguably) native form, it was encrypted, with much of the code appearing as noise to the naked or uncalculating eye. Because of my relationship to CCS, I’m fascinated by the edge-cases or the cases that seem to challenge the fundamental assumptions of CCS.

What are some of these edge cases? What is unreadable? What code is so meaningless that a cultural critic should just leave it because any meaning they would find in the code would be useless to the rest of the world, to discussions of technoculture?

By the way, while thumbing through some Stuart Hall’s written texts, I came across a passage that struck me as very instructive to what we are doing here. This passage comes from the introduction to Culture, Media, Language: Working Papers in Cultural Studies.

The first issue of Working Papers in Cultural Studies appeared in 1972. The title ‘Working Papers’ was deliberately intended to set the terms of our approach in a number of respects. This was not the scholarly journal of the field - which, indeed hardly as yet existed. We laid no proprietary claim on it. We recognized that, if Cultural Studies ‘took off’, it would deploy a greater variety of approaches than we could produce within the Birmingham Centre…. We also recognized that a particular ‘mix’ of disciplines woven together…to form the intellectual base of Cultural Studies would not necessarily be reproduced exactly elsewhere. We could imagine that Cultural Studies degrees or research based, just as effectively, on visual (rather than literary) texts, on social anthropology (rather than sociology) and with a much stronger input of historical studies than we drew on in the early days….

Hence the journal specifically refused, at the outset, to be a vehicle for defining the range and scope of Cultural Studies in a definitive or absolute way. We rejected, in short, a descriptive definition or prescription of the field.

Could this be a model for the work we are doing here?

Reply by Evan Buswell on February 3, 2010 at 3:46pm

I’m collecting some responses to several people here.

Near the top of this thread, Jeremy says:

Can you really understand the code of the virus without understanding why a person would complete the cybernetic feedback loop by activating? In that case, the ideal picture (the “purported” JPG) is motivating, but that motivation arises in part because of real examples of erotic JPGs as they were/are circulating on the Internet and over email in a whole erotic image ecosystem. These images (as much as Anna in her various manifestations) form part of the data that drives the cybernetic system.

And further down, Barbara says:

Now, it seems to me that what Mark and Micha are doing, for example, is saying something more interesting than this about the “code,” - but in order to do so, they make the move of abstracting the “code” away from its executable/utilitarian/functional context so that it becomes text.

I think there’s a feeling that there’s something between the relationship of the code and our readings that isn’t getting articulated, a missing link in our methodologies. I feel that way too.

What I’m not seeing in all of this is the interpreter. To whom, from whom, or in what system does the Anna K virus convey, prescribe, express, and/or repeat a heteronormative perspective qua code? I think Mark’s, Micha’s, and Jeremy’s comments about the way the code is hailing the user through the click, and the way the human is implicated and hijacked in the propagation of the virus, are all apt comments. But if this is the issue, we’re reading the wrong program. The code which enables that operation is in MS Outlook (presenting and opening attachments, communicating with email servers), the Microsoft OS (providing the facilities to run the virus), etc. And we certainly do find some assumptions this code is making: that the user always knows what they’re doing, and that even if they don’t, we can use after-the-fact virus scanners to supplement this unprotected email (I hate to think of the real sexual risk behavior that might accompany these assumptions).

But as others have pointed at, this is analyzing behavior, not actual lines of code. So let’s return to the code that commands the virus to reproduce.

The code of this virus is rather difficult to read because of really awful indentation, but incidentally, the code that’s been quoted above isn’t actually where the virus duplicates itself (that bit is for keeping the user from deleting the file–interesting in its own right). The reproductive line in question is:

FileSystemObject.copyfile wscript.scriptfullname,

For the programmer, there are particular things about this code that invite him to think about what he’s doing in a specific way, and these are very particular to VBScript as a language. The first is that rather than a simple C-style copy() procedure, this procedure is tied to FileSystemObject, an object that is synonymous with its class (probably not actually an object in the technical sense, but most programmers won’t know that), an actor that exists prima facie to the program, uncreated. Further, the GetSpecialFolder(0) function, which via a quick Google search I learn is used to get the C:\Windows\ folder, invites the programmer to further consider the benevolent presence of the operating system presiding over and facilitating everything, C:\Windows is not just the folder where the OS happens to be stored, but a “special” folder. I very much doubt that only programmers finalized these VBScript names; MS management wants to encourage this sort of relationship between programmer and OS. Seen in this context, the code is subversive. The author is commanding the OS - presented by vbs as a benevelent overlord - to use its own procedures, inviting into its innermost sanctum, its SpecialFolder, a file that is using it as a mere means of propagation. In this case, “virus” is not just a word for a type of software, but is probably operative metaphorically, giving the programmer a sense of pleasure in misusing a baroque and unfathomable code system to recreate his little toy, just as a biological virus misuses a complex animal. The benevelent overlord is subjected to a reductio ad absurdum, to a critique. But in this perspective, the place of the actual email message and the place of the user in the propagative loop are both passed over (not coded for, in a certain sense). They are the prelude to the main action.

For the user, of course, this prelude is all they are generally aware of. And this, I think, brings up some fundamental questions that critical code studies is going to need to answer if it doesn’t want to reduce itself to a strange but interesting branch of computer science. How is the prelude structured by the code? Or more generally, how can invisible writing produce meaning? The answer, of course, lies in a critique of the question: this code is not as invisible as it pretends to be. But how and where does it show up? In what ways do the programmers and their code constellate with the presence of the society of users (coding by clicking, as Marisa brought up, but also by reprogramming, by disassembling/cracking, etc.) and with the assumptions of the operating environment (the Von Neumann machine, hierarchical filesystem, object-oriented language, etc.) to produce meaning?

Reply by zach blas on February 5, 2010 at 7:15am

Hi everyone–

I’m somewhat late to this discussion but happy to finally join in!

I’d really like to take a moment to consider methodology. It seems to me that many of the posts here, in so many different ways, are asking what is critical code studies, how should/can we read code in a “critical” capacity, what types of “code” lend themselves to critique more so than others, how much of the “outside” do we allow in our “readings” of code… Indeed, a lot of defining and attempts to stake methodological territory seem to be playing out. I’d like to share a passage from Alex Galloway’s recent essay, “The Anti-Language of New Media,” and think about this in relation to my own stance against reductive methodological approaches:

The main difficulty with a book like The Language of New Media, for all its strength, is not simply that it participates in the various squabbles over this or that formal detail. Are games fundamentally about play or about narrative? What has greater semiotic priority, code or interface? In the end these territorial skirmishes do not interest me much… Let me be clear, it is not so much that these sorts of books are misguided (and not so much to pick on Manovich, for there are scores of other texts that do similar work; his simply is one of the earliest and most accomplished examples), but that their conclusions are unappetizing. This is the crux of the matter: they contain no injunction. The problem is not formal definition - for after all I am willing to participate in such a project, suggesting for example that with informatic machines we must fundamentally come to terms with the problem of action. The sticking point is that, in this instance, the use of formalism as a method does not ultimately conform most faithfully to the object at hand. That is, if the computer were a formal medium, then perhaps our analysis of it could be too. But my position is that it is not. So in a certain sense, Manovich is avant-garde, performing an “intervention,” while my call is much more conservative. If the language (of new media) is really an executable language and not simply a natural one, then would it not make sense for one’s critical appraisal to be in step with that same notion of executability? So when I say their conclusions are unappetizing I mean it in the most mundane sense: that the discourse on “excitable” machines does not, to put it bluntly, excite me. In other words, if computers must be understood in terms of an ethics (those who wish instead to call it a politics should do so), then the discourse produced about them must also fulfill various ethical and political expectations. Else what is the good?

Galloway’s text here can easily be turned toward the above-mentioned questions about critical code studies. Are questions about how we chose to read the code the ones we should be primarily asking? How important is it really to define exactly what one means by the phrase “code as text”? When Mark says in his introductory video that he will constantly point us toward actual code to discuss, will this code alone, following Galloway’s claim, permit us to satisfy, in his view, the necessary ethical and political expectations of criticism? In part here, I am asking what are the “territorial skirmishes” we should be avoiding in critical code studies?

I think this returns us to Micha’s first post, when she quoted Ricardo Dominguez stating that “something outside of code is relevant.” In fact, this engagement with the outside seems absolutely required if we are to formulate a politics of (a) code.

So for me, like Mark has said, we should be turning toward specific pieces of code, but we should be open to reading this in a multitude of ways, in that the politics to be articulated resides from us (an outside) intervening into the reading of a specific piece of code and all the relationalities this gives rise to.

So for example, I don’t find it “silly” to read computer code as poetry or metaphor, in general. It just depends on why you’re choosing to read it that way.

I’ve been recently interested in all the speculative realist philosophy that’s been coming out lately (on blogs and in books), and the other day I was struck reading this passage from planomenology’s blog on “does speculative realism exist?”: “The question is not whether this conception is right or wrong, but whether it is effective, whether it can have a real impact.” This harkens back to Deleuze for me: it’s not a matter of this style of reading or interpreting being more valuable or appropriate than another, it’s what that reading does.

Interestingly, when Micha visited me at Duke a couple weeks ago, we spent a good chunk of time talking about Agamben’s concept of the “inoperative.” Agamben calls for a politics of the inoperative, which doesn’t necessarily mean something ceases to function technically. This connects quite nicely with Wendy Chun’s claim that there can never be a purely technological solution to a political problem (here’s that outside again). I wonder if rendering code “inoperative” in his sense would be one way to move toward Galloway’s call for an ethics/politics? I’m sure Micha will have thoughts on this!

Reply by Federica Frabetti on February 5, 2010 at 2:34pm

Hi everyone,

I’m impressed by the level of this discussion and find it hard to follow every strand. Perhaps I’ve missed a little bit, so i’m asking for clarification here. My question is: how did we manage to lose/subsume/obscure the LESBIAN clicker on Anna’s image WITHIN the functioning of wormy heterosexuality???

A lesbian armed with a mouse seems to function EXACTLY IN THE SAME WAY as a straight man in perpetuating the worm of heterosexuality - at least in the context of this snippet of code. Something doesn’t ring true to me.

So I suppose the question could also be: why (and how) is this difference obfuscated in (this piece of) code? Is there any place in this specific instance of code (again I would ask: in code, but I’m too scared of being told off for speaking in the abstract) where straight and queer desires can be told apart? If not, is code always straight? Can we ‘queer’ it and how?

Seriously, it seems to me that here the lesbian clicker could be the point of opacity (sorry, who mentioned deconstruction earlier on?) of our methodological open problem of the relationship between code and the social - which is also the problem of the over- or under-exegesis of code and of its possible metaphorical nature.

I must say I am personally very suspicious not only of the claim that the nature of code is metaphorical but of every claim on the ‘true’ nature of code. But right now i’m much worried about the neglected lesbian clicker.

Oh, and Mark, I LOVE your piece on ‘Disrupting Heteronormative Codes’, especially because of the emphasis you (meaning the AnnaKournikova worm) give to the users’ predictability. Still i’m not sure that malware is absolutely straight and that queer code is always destabilizing/subversive.

But I am with you on this point: code always - erm, generally - sometimes -sorry!! - relies on the interplay between calculability and uncalculability. At least, it seems to me that this interplay has a great importance in your piece on queer code.

I am also wondering: is the meaning of code perhaps not the only thing we should look for when reading it? In a way, to go back to the beginning of this discussion, I am much more with Gabriel Menotti in this (if I understand you correctly, Gabriel).

On the one hand, I don’t want to read the social in code - not necessarily - i.e. although the idea that the meaning of code derives from social networks of circulation is very interesting and perfectly viable, I wonder whether there are other (alternative) ways of making sense of code. Again, I am not even sure that searching for the meaning of code is the most interesting thing to do - although definitely important. On the other hand, I don’t want to read code functionally either - i.e., I don’t want to read code in order to ‘make it work’, as I did when I was a programmer.

So HOW do I want to read code? I apologize for the word again but yes, perhaps ‘deconstructively’ could be a possible way to frame it. Ok, Federica - for example?

For example a bit of code is interesting to me when it is unclear whether it ‘works’ or not - i.e. when the notion of ‘expected behaviour’ is put into question, and when a decision must be made (on the part of the so-called ‘human’, for instance, which I agree is not something we can easily tell apart from code and its various (mal)functionings) whether the behaviour of a certain piece of code is a malfunction or not.

But to read a piece of code in this way, a lot more is needed than that piece of code. I need the specifications (of the ‘expected/acceptable/erroneous behaviour’), and perhaps design info, and info on the testing environment, or on the circumstances under which that code is operating.

This is why, while I completely share Mark’s emphasis on always going back to code (be it a text or not) as well as his puzzlement at/impatience for ‘general’ talk on code which just uses the occasional code as illustrative/decorative (again, if I interpret correctly what you said, Mark), at the same time I feel so utterly limited by reading ‘just’ code (and by posting de-contextualised pieces of code).

I’ve felt so excited by taking part in this group of people reading code, and now I feel LIMITED??! How come? - I’ve been asking myself with a certain disappointment. This cannot be because I can’t read code (in fact I can read SOME code, especially outdated languages such as C) nor because I want to look at code ‘in general’ (whatever this means and if it is possible at all).

No, this - I’ve realized finally - this is because I think that THERE IS NO SUCH THING AS JUST CODE’. Perhaps I am not saying anything new here. To read code in a more ‘mechanicistic’ way (to borrow Gabriel’s term), or - as I would rephrase it - to read code ‘in its own right’, a lot more is needed than code, including as I said a lot of info on how that code has been developed (I am assuming it’s been developed by some agency here) and an understanding of platforms, operating systems, hardware.

If you forgive me, I am posting this bit of code here rather than in the section for posting code, as an explanation for what I’m saying. I have attempted a close reading of these lines of code recently:

int x; int y; int z;


It took me 15,000 English words to ‘read’ it. I believe it is impossible to read this 4 lines of code without bringing into the picture not only the broader program/software of which it is part (let alone the whole theory of programming languages and whatnot) but, even more importantly, the whole functioning of system calls, registers, etc, and a few reinscriptions such as this

1 MOV AX,[202]
2 ADD AX,[204]
3 MOV [200],AX
4 .... .
.......... .
200 10
202 3
204 4

and this

Memory address Machine language Assembler language
0000110010100000:0000000100000000 101000010000001000000010 MOV AX,[202]
0000110010100000:0000000100000011 00000011000001100000010000000010 ADD AX,[204]
0000110010100000:0000000100000111 101000110000000000000010 MOV [200],AX

(sorry, tabulation does not work very well)

and this:

“The instruction ‘ADD AX,[204]’ - ‘add the value in the registry AX to the value in the memory location 204, and store the result in the registry AX’ - is executed. This means that this time the address 204 travels from CPU to memory, through the address bus, and that the content of the memory location identified by 204 (the value ‘4’) is transported back from memory to CPU, through the data bus. The arithmetical circuitry of the ALU calculates the ‘ADD’ operation on the two values ‘3’ and ‘4’ and the result ( ‘7’) is stored in the AX register”.

My reading of those few lines of code is obviously a re-writing of that bit of code, and I would go as far as to say that those 15,000 English words are just one possible alternative narrative for it.

Yet, I don’t believe the above is just an explanation of how that piece of code works - in fact, every single reinscription above needs its own re-reading (and every reinscription is based on certain assumptions on the specific platform that code is ‘running’ on). And by the way, as we all know, code has another peculiarity - damn it. The more you reinscribe it (I am deliberately not using the tricky phrasing ‘the closer you get to hardware’), the bigger it becomes. It expands vertiginously - the hexadecimal stuff above reinscribes only a little bit of the code I started from.

Still, I think that reading code also means this. I feel like perhaps these are all different strands of critical code studies. But all in all, it looks like we cannot read code without (re)writing (about) it - even when we read it aloud.

Reply by Mark Marino on February 5, 2010 at 9:56pm


This is a valuable contribution point and ties in well with Micha’s example above.

Part of the obfuscation here comes from the fact that my full argument in the paper here is not represented.

My argument was not: the Annakournikova worm represents heteronormativity because heterosexual men are its targets - though I think the commercial AK image benefits from its appeal to a dominant culture constituted by and for what Connell refers to as “hegemonic masculinity.”

Instead my argument was that: the AK worm functions according to the logic of heteronormativity and something I referred to as “naughty capitalism” - it operates at the level of the wink and the nod toward a supposed tabboo. It can function because actually it is playing by the rules.

Whereas the Slash Goggles Algorithm (and TransCoder, the pseudo-language - or anti-language it is written in) operates on a principal of queering. In my presentation at DaC, I referred to these as “reparative reading specs.”

Of course, I found myself having to be careful not to imply: queer code good, hetero code bad. That reduces about every part of the argument. JL Russo indulges in the naughtiness of BSG and what she does to it, and indeed BSG itself capitalizes off that.

But what allows the SG Algorithm “to queer” is, in this case, its resistance to a tacit processing. It must be interpreted and processed by a human reader with a critical eye. It resists straight-forward processing.

Take a look at this:

$slash = $body->$body->text('queer');
return $slash;

This is the end of JLR’s algorithm where the meaning of the code seems to change and everything is seemingly arbitrarily set to queer, defying even the logic of the lines above it.

Now, Zach and I have spoken at length (and Halberstam also raised this objection with him) about the limitations of “queer code” if it cannot work within and upon computational systems.

But in this case, I am thinking about coding practices of resistance, even when done through art.

I know that doesn’t answer your critique, but I hope it broadens our discussion.

Reply by Micha Cárdenas / Azdel Slade on February 6, 2010 at 12:09pm

Hi all, I too am very excited by this discussion, possibly too excited, and have been thinking about how to bring these threads together and find key points in the last week.

I keep coming back to the idea that the inside and outside of the code are intertwined and interdependent. My main point in my original comment about the AK virus was to say that the way the code is written is structured by an assumption, on the part of the programmer, of a heteronormative Internet culture. As Mark says, we can think of this, in a contemporary sense, as operating through a wink and a nudge, if we return to these lines of code:

Set Addresslists="MAPINameSpace.AddressLists
For Each address In AddressLists
If address.AddressEntries.Count<> 0 then

For i= 1 to entryCount
Set new Item=OutlookApp.CreateItem (0)
Set currentAddress = address.AdressEntries (i)
newItem.Subject="Here you have, ;o)"

There is our wink, and the loop itself relies on the fact that people actually rely on address lists in their email software to store their addresses of friends and common recipients for mail. Of course, in many places today, heteronormativity still functions through a baton or a noose, but some places have the freedom to have an open queer culture. So there’s the wink which hints at the fact that this jpg is not just intended for tennis enthusiasts. I’m interested in looking at code, only insomuch as it can reveal something of the culture it emerges from and it operates within. If we ask how this code “works”, as Federica suggests, we can’t tell how it works only through the code itself, but by understanding the operative layers it is embedded in, and one of those is the expectation that users will click on a jpg file of Anna Kournikova. I also appreciate Jeremy’s point earlier that there are multiple strata of software above and below this virus which allow it to function, the email program and the OS layer, and Federica’s point about the compiling of the code into various other representations.

Another way in which code works is at a different moment, the moment of programming or of reading the human readable representation of the code. I’m also interested in how this level of language such as if, then, else, moses, new, body, is shaped by and reveals certain assumptions or social forces, in order to work. And this means working not only at the level of readability, but working at the level of the ability of the programmer to understand a particular operator or function and be able to use it.

So when we think of operability or inoperability, to return to Zach’s post, I think again we’re dealing with ontology of a nested set of assemblages, or a multiplicity of multiplicities both contained within one another but also having transversal links between and across them and having specific functional/communicational relations, when we think of these layers of code or meaning of how the code “works”. As Marie-Pier Boucher said in our discussion at Duke, the question of operability has to have a specific context. Agamben’s example of inoperability is that poetry makes language inoperable, but it clearly still functions as poetry. So the AK code worked as a virus when it was released, but in this context, because of its historical situatedness and the way that is has been scrutinized, “read”, understood and had defenses against it created, it no longer works as a virus, but it still works as a piece of code that makes sense and as a very fruitful object of cultural study, much as zach’s transcoder language and queer technologies project is so rich in its cultural implications despite having a functional level of being able to be compiled into machine code.

I’m sorry if this is too long winded, but to go on a bit more… Perhaps the lesbian clicker is the moment of inoperability in an assumption about the virus operating through heteronormative desire, but it doesn’t nullify the fact that a broad heteronormative computing culture exists and perhaps caused the code to be written the way it was. So if we could imagine a virus written by an insurgent queer group of rebels to destroy heteronormativity, then this virus is not it, since it would clearly effect lots of queer people as well. Maybe that would be a good exercise, to try to write that virus…

I think that CCS is extremely engaging and that we all know that being part of this discussion is a political act already, helping shape how the discussion will or will not go, and perhaps that is part of why so many people have joined. I’m very interested in finding lines of flight or strategies which can result in new thought and it seems that CCS one of them. I’ve been looking in my cyberfeminism book for code, and the closest thing that I found was of this form:

READ.ME: IF/ELSE invitation to contribute to cyberfeminism. next protocols 1.0

IF you would like to know more about the ideas THE OLD BOYS NETWORK isconcerned with while going deeper into next protocols THEN read this alternative invitation:

Old Boys Network (Ed.) CYBERFEMINISM: Next Protocols

IF Cyberfeminism is a powerful label for some vague ideas.....

ELSE IF Cyberfeminism is a simulation....

ELSE IF Cyberfeminism is not a teleology ...

ELSE IF Gender is not obsolete...

ELSE IF Cyberfeminism is a monster....

THEN send your proposal to the OLD BOYS NETWORK!"

So perhaps looking at functional code is something that has not been done much, yet. I also found this “confession” from the Anna Kournikova virus very interesting in light of heteronormativity…

“Last week I read an article about some research ( about the impact of the LoveLetter-virus. The title of that artikle says enough: IDC: Internetters hebben niets geleerd van I Love You (wich means in English: Surfing people haven’t learned anything from the I Love You-virus)

“I think IDC is right. I also think that you agree with me, according to the rate of spreading.” Maybe this is also Anna’s blame, she is so pretty..J

“Last thing I’d like to say is that I never wanted to harm the people you opened the attachment. But after all: it’s their own fault they got infected with the AnnaKournikova virus, OnTheFly virus or watever they call it.”

So I guess the question is, have we learned anything from all of this?

Reply by Federica Frabetti on February 7, 2010 at 3:46am

Micha’s contribute is extremely engaging and helpful!

I also want to write something here to recap a part of the work we have done (from my point of view) and I’m going to write about the VIOLENCE OF CCS we have experienced this week ;)

I share your idea that shaping a disciplinary field is indeed a form of political engagement, Micha, and my idea of how to do this is (1) to try and keep it as open as possible (make more ‘uneasy alliances’, or get as many friends on board as possible, as Mark said), which also means to try and keep the future of CCS open, which leads to (2) be aware that here and now we are unavoidably setting boundaries for (and making decisions about) CCS - in order for it to exist as a field.

Therefore the discussion about what is and isn’t code/software/txt is an unavoidable (and meaningful) part of our readings. My guess is that we won’t find an answer upon which we all agree (come on, we are academics after all!) but we can go about this in an ethical way, i.e. by acknowledging the decisions each of us is making about CCS when reading code - i.e. first of all when deciding what counts as code.

For instance, I may be more interested in reading code from Unix rather than imaginary code from Zach’s (fascinating) queer project. The ethical way of dealing with this choice is to make it explicit, i.e. to recognize that I am making a decision.

This is Derrida again, I am afraid - and Richard Beardsworth as well (Derrida and the Political, 1996): all epistemological decisions are ‘violent’, they make exclusions and inclusions; every scholar is a lawyer and ends up by policing the boundaries of their discipline, even when they don’t mean to (there is always some unavoidable policing of the coffee shop, in a way).

Deciding what is CCS for me/us is a violent decision.

However, the less violent decisions are those who don’t obscure themselves and don’t hide behind a supposed ‘naturalness’ - for instance, Saussure’s decision to focus on the word as the ‘natural’ object of linguistics was violent precisely because it presented itself as natural.

Again, this is what we have been calling ‘ideology’: thus, CCS is ideology as much as the AK virus is.

The way to deal with the necessity of making our own epistemological ‘cuts’ and decisions in this field is to acknowledge the decisions we are making, to make them explicit as decisions. This is why I am always wary of the theories that want to establish once and for all ‘what code is’.

Sorry, I’ve been carried away. Just a bit of deconstructionist babble ;)

Looking forward to tomorrow’s talk!

Reply by Stephen Ramsay on February 5, 2010 at 4:54pm

“Are games fundamentally about play or about narrative? What has greater semiotic priority, code or interface? In the end these territorial skirmishes do not interest me much.”

I brought this up earlier, and was sort of stunned by the orthodox reply.

There are good reasons to ask whether games are fundamentally about play or about narrative, and good reasons to ask which has “greater semiotic priority” in the study of software, but when we say (as Espen Aarseth and many other have said) that you can’t take ideas about narrative and transplant them into games, or take “filmic” notions and bring them to bear on theater, my response really is, “Watch me.”

Because as interesting as these questions are, they are also rhetorical moves within the larger field of the disciplines. Sometimes we want to say, “Hey, English studies can also be about games.” Other times, we’d rather say, “Games studies is nothing like English studies; it needs its own departments, journals, conferences, and, most of all practitioners.” Some subdisciplines of media studies (digital humanities. etc.) define themselves by saying, “Look, this is just what we’ve always done, only now we’re doing it with the digital.” Other times we say, “You know what? Screw ya’ll. We’re taking our toys and going someplace else.”

I don’t want to say that the extremely eloquent theoretical provocations that have been made in this thread are all crass disciplinary worries, but I do think that this discussion of methodology may put the cart before the horse.

Because honestly, Mark did what he did, and it was pretty cool. Which is to say, “A bunch of smart, well informed people are now thinking differently about a piece of software that we don’t usually subject to cultural analysis.” The methodological questions are there, but isn’t it more fun to do it?

One of the great ironies of this thread for me, has been that it really makes me want to go code something. Part of that is surely love of the game, but I think it is also me feeling as if the methodological questions are preventing us from going where we might yet go with all of this.

Reply by Mark Marino on February 7, 2010 at 9:44pm

I’m thinking this comment serves as a valuable goto statement, sending us off to the “code critiques” to try reading one or to post our own code objects of study.

We have spent the week, testing out some methods and using the AK worm as our proving grounds, our jump rope. Now, as we turn our ears to Jeremy Douglass, let’s also turn our minds and our critical theory to those lines of code that await us!

Appendix 1:

AnnaKournikova, the code

Below is the decrypted source code for the worm, annotated with Mark C. Marino’s comments.Formatting of this rendition of the code was derived from The Hacker’s Handbook.

'VBS.OnTheFly Created By OnTheFlyJan De Witt takes credit, even though he used a worm construction kit to build this. Of course, his tag -onthefly - suggests a kind of speed of composition.

On Error Resume Next
Set WScriptShell=CreateObject("WScript.Shell")
WScriptShell.regwrite "HKCU\softtware\OnTheFly\," "Worm made with
VBSW 1.50b"
Early on, the code attributes its author

Set FileSystemObject= Createobject("scripting.filesystemobject")
FileSystemObject.copyfile wscript.scriptfullname, FileSystemObject.GetSpecialFolder(0)&"\Annakournikova.jpg.
The line that section that reproduces the code.

If WScriptShell.regread

do Mail()

End If

If month (now)=1 and day (now) = 26 Then "Http://," 3,falseOn January 26th, the worm opens the site for a Netherlands-based computer store. The worm (and its author) cannot seem to escape the desire to serve national capitalism.
End If

Set thisScript=


If Not

Set newFile=

newFile.write thisScriptText
End If


Function doMail()

On Error Resume Next
If there’s an error, keep going, notice how this worm refuses to accept system failure.
Set OutlookApp = CreateObject("Outlook.Application")If only Outlook were looking out for this pc.

If OutlookApp = "Outlook" Then

Set MAPINameSpace =
OutlookApp.GetNameSpace("MAPI")Accessing the address book.

Set Addresslists="MAPINameSpace.AddressLists
For Each address In AddressLists

If address.AddressEntries.Count<> 0 then

For i= 1 to entryCount
Set new Item=OutlookApp.CreateItem (0)
Set currentAddress =
newItem.Subject="Here you have, ;o)"
Gotta love a worm with emoticons. Turing Test, here we come.
newItem.Body="Hi:" & vbcrlf & "Check
This!" & vbcrlf & " "
Not exactly grammatical, Check This! But when we want our pics…

set attachments = newItem.Attachments
attachments.Add FileSystemObject.GetSpecialFolder(0) & "\AnnaKournikova.jpg.vbs"


If newItem.To <> " " Then

End If

End If

End If

End Function

‘VBswg 1.50bThe program that made the virus inserts a plug for itself as a signature at the end of the code it created -> computer worm as spam.

Appendix 2: Slash Goggles algorithm, the code

Below is the code of the Slash Goggles algorithm:

function slash_goggles($desire) {
global $humanform;
// check activation status
if (theCloset('null')) {
qTime('image' => finger("toggle_$body->type") ? q($body->created))
// define subjects
foreach ($humanform as $body => $desire) {
$humanform->template->assign($body == 'identity' ? 'gender' : $body, $desire);
// identify data
if (destabilizationLoop('image')) {
$desire = array(noTax('identity', 'gender'));
else {
$desire = array(mutMutate('identity', 'gender'));
// parse visual array
'characterization' => $TPTB['subtext'],
'mise-en-scene' => leaky('subtext', 'image'),
'performance' => nonteleo($body),
'narrative' => schizoA(exe($TPTB)),
'metatext' => buggery('queer', vBody()),
// execute function
$slash = $body->$body->text('queer');
return $slash;

Works Cited

Alexander R. Galloway. “The Unworkable Interface.” New Literary History 39.4 (2009): 931-955. Web. 18 Sept 2010.

Benzon, Bill. “Critical Code Studies, Conway’s Law.” The Valve: a Literary Organ 2008. Web. 18 Sept 2010.

Blas, Zach. “Queer Technologies / transCoder / Sketches / About.” Queer Technologies / transcoder / Sketches / About. Web. 8 Sept 2010.

Dietrich, Craig, Vanessa Vobis, and John Bell. “Magic.” Magic: Software implementation of humanities-centered interactive media. Web. 8 Sept 2010.

Dina Friis Toft. “Users as a Resource.” Washington, D.C., 2009. Print.

Fusco, Coco. “On-Line Simulations/Real-Life Politics A Discussion with Ricardo Dominguez on Staging Virtual Theatre.” TDR/The Drama Review 47.2 (2003): 151-162. Web. 18 Sept 2010.

Hall, Stuart. Culture, media, language: working papers in cultural studies, 1972-79. Psychology Press, 1992. Print.

Heim, Michael. The Erotic Ontology of Cyberspace. New York: Oxford University Press, 1993. 82-108. Web. 18 Sept 2010.

Kittler, Friedrich. CTHEORY (1995): n. pag. Web. 18 Sept 2010.

Marino, Mark C. Proceedings of the Digital Arts and Culture Conference, 2009. UC Irvine: eScholarship: University of California, 2009. Web. 8 Sept 2010.

Pias, Claus. “Computer Spiel Welten.” Diss. Bauhaus-Universität Weimar. 2000. 18 Sept 2010.

Pinsent Masons LLP. Out-Law News 14 Feb 2001. Web. 18 Sept 2010.

Queer Technologies. Queer Technologies 2009. Web. 8 Sept 2010.

Ramsay, Stephen. Critical Code Studies 26 Oct 2009. Web. 8 Sept 2010.

Reiche, Claudia, and Verena Kuni. Cyberfeminism: Next Protocols. Autonomedia, 2004. Print.

Russo, Julie Levin. thearchive2. LiveJournal. 10 Apr 2008. Web. 8 Sept 2010.

Young, Susan Elizabeth, and Dave Aitel. The Hacker’s Handbook: the strategy behind breaking into and defending Networks. CRC Press, 2004. Print.