Notes for Wendy Hui Kyong Chun “On 'Sourcery,' or Code as Fetish”

Key concepts: codework, erasure of execution, ideological belief in programmability, iterability, machinic performative, new media, performative, productively spectral interfaces, real time, sourcery, vicissitudes of execution, volitional mobility.

Related theorists: Butler, Cicero, Dijkstra, Matthew Fuller, Galloway, Hayles, Lovink, Manovich, McCulloch, Tara McPherson, Mez, von Neumann, Pitts, Stallman, Zizek.

Expression of extent of new media in digital age of the Internet and question of comprehensibility, knowing its essence is software.

(300) It seems impossible to know the extent, content, and effects of new media. . . . Who can expertly move from analyzing social-networking sites to Japanese cell-phone novels to World of Warcraft to hardware algorithms to ephemeral art installations? Is a global picture of new media possible?
(300) All new media allegedly rely on—or, most strongly, can be reduced to—software, a “visibly invisible” essence.

Fetishism of sourcery obfuscates the vicissitudes of execution, obverse of valorization of user agent, the goal making productively spectral interfaces rather than true understanding of machines.

Question for philosophy of computing is to debate conclusion to not aim for understanding of machines, calling for compensatory disciplines as Heim recommends to offset effects on close reading and handwriting practices of word processing, for which I recommend projects of manageable complexity such as repairing early electronic pinball machines.

(300) But, what is software? What does it mean to know software and, most importantly, what does positing software as the essence of new media do? This essay responds to these questions, arguing that software as source relies on a profound logic of “sourcery--a fetishism that obfuscates the vicissitudes of execution and makes our machines demonic. Further, this sourcery is the obverse rather than the opposite of the other dominant trend in new media studies: the valorization of the user as agent. . . . To break free of this sourcery, we need to interrogate, rather than venerate or even accept, the grounding logic of software. Crucially, though, closely engaging software will not let us escape fictions and arrive at a true understanding of our machines, but rather make our interfaces more productively spectral.

The Logos of Software

Invokes Manovich, Lovink, Galloway as well as folk wisdom: attacking unformed we-have-never-been-modern philosophy of computing carelessly grounded in software studies or even CCS?

(301) To exaggerate slightly, software has recently been posited as the essence of new media, and knowing software as a form of enlightenment. . . . Software, after all, is ephemeral, information ghostly, and new media projects that have never, or barely, materialized are among the most valorized and cited. . . . we all know some software, some programming languages, but does anyone really “know” software?
(302-303) I am arguing that we need to interrogate how knowing (or using free or open source) software does not simply enable us to fight domination or rescue software from evil-doers such as Microsoft, but rather is embedded in—mediates between, is part of—structures of knowledge-power. . . . More subtly, the free software movement, in insisting that freedom stems from free software—from freely accessible source code—amplifies the power of source code, erasing the vicissitudes of execution and the structures that ensure the coincidence of code and its execution. It buttresses the logic of software—that is, software as logos.
(302 note 8) The underlying assumption is that if intellectual-property rights remain the same, but rights are exercised differently by their owners, free culture would emerge.

FOSS epistemological transparency buttresses software as logos, and may conceal vicissitudes of execution, all that happens between linear source code and distributed run time conditions, exemplified by Dijkstra dislike of goto; nonetheless, footnote on importance of FOSS in knowledge-power can be related to Heidegger Nietzsche lectures. Important point is

(303) The goal of software is to conflate an event with a written command. . . . An example I've used elsewhere, Edsger Dijkstra's famous condemnation of “go to” statements, encapsulates this nicely. . . . because go to statements work against the fundamental tenet of what Dijkstra considered to be good programming: namely, the necessity to “shorten the conceptual gap between static program and dynamic process.”
(304) in the military, there is supposed to be no difference between a command given and a command completed, especially to a “girl.” The implication here is: execution does not matter—as in conceptual art, execution is a perfunctory affair; what really matters is the source.

Hayles distinction between linguistic and machinic performative on desired efficacy of source code complicated by contesting inside versus outside of machine.

(304) [quoting Galloway Protocol: How Control Exists after Decentralization] “Code is the only language that is executable.” Drawing in part from Galloway, N. Katherine Hayles, in My Mother Was a Computer: Digital Subjects and Literary Texts, distinguishes between the linguistic performative and the machinic performative.
(304 note 16) Hayles's argument immediately poses the question: What counts as internal versus external to the machine, especially given that, in John
von Neumann's foundational description of stored program computing, the input and output (the outside world of the machine) was a form of memory?

Galloway journal choice Visual Culture reflects software studies pulls visual culture discourse back to semiotics in a remediation of the visual in meditation upon how the aural is produced by the symbolic.

(305) The independence of machine action—this autonomy, or automatic executability of code—is, according to Galloway, its material essence: . . . [quoting] Code essentially has no other essence for being (sic) that instructing some machine in how to act. One cannot say the same for the natural languages.

Assumption that code is automatically executable borders fantasy: commensurability of levels of code/constitution may reduce to equations, but more to technical than numerical relations; source code compilation to executable form is not trivial transformation.

(305-306) To make the argument that code is automatically executable, the process of execution itself must not only be erased, but source code also must be conflated with its executable version. . . . to push Galloway's conception further, a technical relation is far more complex than a numerical one.

Nice example of working code of assembly language mnemonically more complex that 6502 assembler I once thought I understood.

(306) Significantly, a technical relation engages art or craft. . . . This compilation or interpretation—this making code executable—is not a trivial action; the compilation of code is not the same as translating a decimal number into a binary one; rather, it involves instruction explosion and the translation of symbolic into real addresses. Consider, for example, the instructions needed for adding two numbers in PowerPC assembly language, which is one level higher than machine language.

Virtuality of source code because not all compiled code is ever executed, especially edge conditions.

(307) It is, rather, a breakdown of the steps needed to perform what seems a simple arithmetic calculation. . . . Also, some programs may be executable, but not all compiled code within that program is executed; rather, lines are read in as necessary. So, source code thus only becomes source after the fact. Source code is more accurately a re-source, rather than a source.

Schematics are sourcery too, concealing critical timing conditions under which they are valid representations of the designed behavior; clever conjunction of von Neumann, McCulloch, Pitts, and Faust.

(307-309) Code is also not always the source, because hardware does not need software to “do something.” One can build algorithms using hardware, for all hardware cannot be reduced to stored program memory. Figure 1 [a circuit schematic], for instance, is the logical statement: “if notB and notA, do CMD1 (state P); if notB and notA and notZ OR B and A (state Q), then command 2.” . . . Crucially, this schematic is itself an abstraction. Logic gates can only operate “logically” if they are carefully timed. . . . This schematic erases all these various time-based effects. Thus hardware schematics, rather than escaping from the logic of sourcery, are also embedded within this structure. Indeed, John von Neumann, the alleged architect of the stored-memory digital computer, drew from Warren McCulloch and Walter Pitts's conflation of neuronal activity with its inscription in order to conceptualize our modern computers. . . . That is, the response of a neuron can be reduced to the circumstances that make it possible: instruction can substitute for result. . . . At the heart of stored-program computing lies the Faustian substitution of word for action.

The automaticity of code is the mystery, compared again to Cicero wishing for executability.

(309) What is surprising is the fact that software is code, that code is—has been made to be—executable, and that this executability makes code not law, but rather every lawyer's dream of what law should be, automatically enabling and disabling certain actions and functioning at the level of everyday practice.

Source Code as Fetish

Docility of hardware required for programmability; architectural axiomatics necessarily limit decodings.

(309-310) software is always posited as already existing, as the self-evident ground or source of our interfaces. . . . As an axiomatic, it, as Gilles Deleuze and Felix Guattari argue, artificially limits decodings. . . . Programmability, discrete computation, depends on the disciplining of hardware and the desire for a programmable axiomatic. Code is a medium in the full sense of the word. As a medium, it channels the ghost that we imagine runs the machine—that we see as we don't see—when we gaze at our screen's ghostly images.
(310) Understood this way, source code is a fetish.
(311) The parallel to source code seems obvious: we “primitive folk” worship source code as a magical entity—as a source of causality—when in truth the power lies elsewhere, most importantly in social and machinic relations. If code is performative, its effectiveness relies on human and machinic rituals.

Epistemological transparency offered by free, open source code is illusory, depending on erasure of compilation and execution, the surrounding social and machinic rituals; also undermines sourcefulness of codework, or at least points to other meanings besides executability, thinking of Mez.

Source code can engender things besides machine execution, from literary codework to pseudocode used for thinking about programming.

(312) Against this magical execution, source code supposedly enables pure understanding and freedom—the ability to map and understand the workings of the machine, but again only through a magical erasure of the gap between source and execution, an erasure of execution itself.
(313) This notion of source code as readable—as creating some outcome regardless of its machinic execution—underlies “codework” and other creative projects. . . . Regardless of whether or not it can execute, code can be, must be, worked into something meaningful. Source code, in other words, may be sources of things other than the machine execution it is “supposed” to engender.

Fetish territorializes, turns time into space, meaningful fixation of a singular event that is repeated; see Zizek.

(314) As such, it both fixes a singular event—turning time into space—and enables a logic of repetition that constantly enables this safeguarding. As Pietz argues, “the fetish is always a meaningful fixation of a singular event.”
(315) Fetishists importantly know what they are doing—knowledge is not an answer to fetishism. The knowledge that source code offers is therefore no cure for source-code fetishism: if anything, this knowledge sustains it.

Summary of why source code is a fetish: ideological belief in programmability, ignoring vicissitudes of execution, timing requirements for even schematics to be working models.

(315) To make explicit the parallels, source code, like the fetish, is a conversion of event into location—time into space—that does affect things, but not necessarily in the manner prescribed. Its effects can be both productive and nonexecutable. Also, in terms of denial and acknowledgment, we know very well that source. And it is this glossing over that makes possible the ideological belief in programmability.

Epistemological transparency is a fetish reaction tied to ideological belief in programmability; seems like a program of studies in ECT would help dispel the delusions of meaningful coincidences.

(315-316) This erasure of execution through source code as source creates an intentional authorial subject: the computer, the program, or the user, and this source is treated as the source of meaning. . . . That is, because an interface is programmed, most users treat coincidence as meaningful. To the user, as with the paranoid schizophrenic, there is always meaning: whether or not the user knows the meaning, she or he knows that it regards her of him. . . . To know the code is to have a form of “X-ray” vision that makes the inside and outside coincide, and the act of revealing sources or connections becomes a critical act in and of itself.

Real Time, This Time
(316) This discussion of the user brings to light an interesting fact: the notion of user as source, introduced through real-time operating systems, is the obverse, rather than the antidote, to code as source.
(316-317) The notion of real time always points elsewhere—to “real-world” events, to user's actions—thereby introducing indexicality to this supposedly nonindexical medium. . . . What is authentic or real is what transpires in real time, but real time is real not only because of this indexicality—this pointing to elsewhere—but also because its quick reactions to user's inputs.

Real-time posits user as source, from McPherson volitional mobility to Turkle robotic moment; television versus web phenomenology of liveness; contrast to Manovich telepresence.

(317) Dynamic changes to webpages in real time, seemingly at the bequest of users' desires or inputs, create what Tara McPherson has called “volitional mobility.” . . . [quoting] Thus, unlike television which parades its presence before us, the web structures a sense of causality in relation to liveness, a liveness we navigate and move through, often structuring a feeling that our own desire drives the movement.
(317) This volitional mobility, McPherson argues, reveals that the “hype” surrounding the Internet does have some phenomenological backing.

Interfaces erase the medium in computation.

(318) The source of a computer's actions always stems from elsewhere, because real time makes it appear as though only outside events—user mouse-clicks, streaming video—cause the computer actions. These real-time interactions, which were initially introduced to make computation more efficient, have almost erased computation altogether. . . . Viewed as the alpha and omega of our computers, interfaces stand in, more often than not, for the computer itself, erasing the medium as it proliferates its specters, making our machines transparent producers of unreal visions—sometimes terrifying, but usually banal imitations or hallucinations of elsewhere.

Demonic Media

Seems to get lost here in hermeneutics of UNIX daemons, getting sleep wrong in the Perl program, confusing seconds for minutes; also confusion of interactive, multi-tasking, multi-user operating systems with real-time.

(318) Not accidentally, this spectrality of digital media makes our media demonic; that is, inhabited by invisible processes that, perhaps like Socrates daimonion (mystical inner voice), help us in our time of need. They make executables magic. UNIX—that operating system seemingly behind our happy spectral Macs—runs daemons.
(320) The most famous daemon is perhaps Socrates'
daimonion—that mystical inner voice that assisted Socrates in time of crisis by forbidding him to do something rash. The other famous daemon, more directly related to those spawning UNIX processes, is Maxwell's demon.
(320) Real-time operating systems, such as UNIX, transform the computer from a machine run by human operators in batch mode to “alive” personal machines, which respond to users' commands.
(321) Should these daemons be exorcised, or is this spectral relationship not central to the very ghostly concept of information and the commodity itself?

Code as Re-Source
(321-322) This gap [between code and execution] complicates any analysis of user determination by software. . . . Reading Microsoft Word's mammoth feature mountain, [Matthew]
Fuller compellingly argues that the more features offered in an anxious attempt to program the user—the more codes provided—the more ways the user can go astray. . . . Second, code as re-source allows us to take seriously the entropy, noise, and decay that code as source renders invisible.

Butler performative depends on iterability, which is institutional and political as well as machinic.

(322) This larger view of the performative has been developed by Judith Butler, who argues against that the felicity of a performative utterance does not depend on the sovereign subject who speaks it. Instead, she argues that what is crucial to a performative utterance's success or failure is its iterability. . . . What is crucial here is: first, code that succeeds must be citations—and extremely exact citations at that. There is no room for syntax errors; second, that this iterability precedes the so-called subject (or machine) that is supposedly the source of the code; and third, and most importantly, an entire structure must be in place in order for a command to be executed. This structure is as institutional and political as it is machinic.

Emphasis on imagined institutional and political networks in free software philosophy of Stallman.

(323) The difference between open source and free software lies in the network that is imagined when one codes, releases, and uses software—the type of community one joins and builds when one codes. The community being cited here, worked through, is one committed to this notion of freedom, to coding as a form of free speech. Open source and free software movements are aligned, however, in their validation of “open”: freedom is open access.

Capture ghosts by algorithmic procedures, technological docility.

(323) Capturing ghosts often entails looking beyond what we “really” see to what we see without seeing, and arguably, digital media's biggest impact on our lives is not through its interface, but through its algorithmic procedures. . . . Capture re-works the notion and importance of access: one does not need a “personal computer” in order to be captured—all one needs is a RFID tag or to work in a factory or to simply be in debt.

In media res, flashback understanding of software versus chronology; must begin with things.

(323-324) This necessary imagining also means that software can only be understood in media res—in the middle of things. “In media res” is a style of narrative that starts in the middle as the action unfolds. Rather than offering a smooth chronology, the past is introduced through flashbacks—interruptions of memory. . . . Software in media res also means that we can only begin with things—things that we grasp and touch without fully grasping, things that unfold in time—things that can only be rendered “sources” or objects (if they can) after the fact.

Chun, Wendy Hui Kyong. "On 'Sourcery,' Or Code As Fetish." Configurations: A Journal Of Literature, Science, And Technology 16.3 (2008): 299-324. Web. 12 Dec. 2012.