Raley, Mateas, and Montfort approach code as both an aesthetic object as well as an executable object, or as Raley describes the difference, “code-as-text and code-as-operation” (3. Reading Code, n.p.). A critical aspect of code is, of course, that one cannot read code while it is being executed by a machine. Thus, when artists reconfigure code as literary objects, what they call out “is not the mechanism itself but a representation of the mechanism” (1. Code.surface|Code.depth, n.p.). In revealing the mechanism through its representation, they comment on code (or film in Raley’s opening example) as a mechanism of representation. By remaining within the apparatus of representation, however, the unmasking of codes is also a concealing of them, burying them under further layers of representation.
These additional layers, surface effects designed to accommodate human sensory relays, to return to Kittler, may shed some light on the wizardry taking place behind the curtains. Or, in the case of the weird languages Mateas and Montfort describe, they may further obfuscate seemingly simple operations with language play. What are the limits of code semantics for an audience of computers? of programmers? of laypersons? It seems that the permutations of language central to code aesthetics, whether in Caley, Mez, or weird languages, forces code to hover and vibrate between excess signification and indecipherability. They make language strange, revealing not the codes but the arbitrariness of codes.
Code thus produces far more than the screenic effects we expect. Code aesthetics hold perhaps once unforeseen consequences for so-called natural languages, and indeed, computational models for social analyses are nothing new. Mackenzie, however, suggests that code operates at a level that the other authors hint toward but do not address. He indicates the performativity of code not only at the level of its machinic execution, which Raley also discusses, but at the level of its social function.
The Linux kernel circulates in multiple versions and operates across platforms, recycling and citing itself with each successive iteration. Mackenzie thus turns to a performative model, collapsing performative utterances, in which speaking performs an action (I promise, I bet, etc.) with performative acts, wherein egos or identities congeal around their performances. Linux, Mackenzie argues, is performative because as code, it executes its statements, and as an object, it cites itself. But Mackenzie takes performativity a step further and suggests that the true output of Linux is not an operating system or whatever an operating system might enable. As a circulating cultural object, Linux produces a community of (male) programmers.
Notably, however, Mackenzie locates Linux’s origins in a clone of Unix, thus troubling the connection between Linux and the performative acts which constitute Linux. Performative acts have no identifiable source. Their function is to naturalize themselves through perpetual iteration. Layers and layers of performances cover the fact that there is no subject performing them—there is no original operating system, only the performance of codes.
Thus we return to Raley, but with a difference. No longer are we presented with “code-as-text and code-as-operation,” now we have codes performing as text and codes performing as operation. The question then is: “Can the codes performing as text shed some light on the codes performing as operation?”