Reviewing the week's discussion of Programmed
Visions, Sarah Zurhellen finds a pleasurable respite that,
necessarily, generated as many questions as answers.
About twice a week my dad opens his 2005 Toshiba laptop and prepares "to compute," as he calls it. Using both hands, he gently raises the screen and shifts the computer's weight until it is evenly distributed across his lap. Then he lifts his hands toward his face and, beginning with the pinkie and moving toward the thumb, softly blows air across his fingertips. The first time I saw this ritual, I stared until he looked up at me quizzically and said "What? I'm just warming up my fingers." Still not understanding, I asked for what exactly was he warming up his fingers. The reply, "For the computer. It doesn't always recognize my fingers." Then I watched as he maneuvered the trackpad, and then I understood. My dad has worked in construction, as a framer, for over thirty years, and one of the many consequences of his labor is that his fingers are about four times the size of average fingers and the extra thickness is primarily composed of calluses. I saw that the problem was two-fold: he couldn't feel exactly what his fingers were doing on the trackpad and the trackpad couldn't always identify that a finger was touching it. Although I've since made some changes to his trackpad settings that allow it to be more alert to my dad's particular finger movements, he still begins each session by blowing on his fingertips.
For all of the reasons you can imagine, I love this anecdote, and as a trained and practicing humanist, I have considered it endlessly. It serves as an example of tactile cognition, technological failure, Nigel Thrift's "technological unconscious," Heidegger's notion of technics, the list could go on and on. It incessantly returns as I try to teach my students to navigate new digital tools and get them to think about how their mistakes open up spaces of discovery. Nevertheless, it was our shared text for Week 4 of the Critical Code Studies Working Group - Wendy Hui Kyong Chun's first chapter from her forthcoming book Programmed Visions: Software and Memory - that challenged me to rethink the anecdote of my dad's fingertips in relationship to notions of ritual and magic that undergird so much of our technological practice.
In this chapter, Chun introduces the term "sourcery" to signify what she sees as contemporary culture's fetishism of source code. Software (source code), Chun claims, "is a magical force that promises to bring together the fractured field of new media studies and to encapsulate the difference this field makes" (2). Engaging the claims of Lev Manovich, Alexander Galloway, N. Katherine Hayles, and others, Chun pushes against the reification of source code as source by situating its emergence in history and exposing how the division of labor and the demand for standardization in programming steered the development of software. Code, Chun reminds readers, only becomes source code after a series of executions that may or may not take place. Source code, therefore, is always deferred, becoming "source only through its destruction, through its simultaneous non-presence and presence" (6). The concurrent presence/non-presence of source code makes for murky analyses, but Chun insists that it is by wading through the murk (or vapor, as she calls it) that productive critical readings of code can be established.
Taking the "vaporiness" of code and reading it through the linguistic and material practices that created "software as thing," Chun questions our very ability to speak of code without "the inevitability of ... anthropomorphization" (4). However, Chun suggests, that what we do with code when we talk about it (anthropomorphize it) highlights the very structures of power at play in the making of code into source code. We program and are programmed by our software (and hardware). In the final analysis, it is not source code but us - users and programmers alike - who perform "the Faustian substitution of word for action" when we assume code's executability (7).
Chun's chapter enacts the simultaneous destruction/reconstruction of source code as she demystifies software by reading what we do to it alongside what it does to us. Foregrounding the notion that construction takes place in both directions (we program and are programmed), Chun's chapter generated a productive conversation constituted by both close readings of code and meta discourse on the practice(s) of reading code. Concomitantly engaging CCS Critical Code Studies (CCS) at both the micro and macro levels, the Week 4 discussion raised questions such as the following:
Will thinking through code-as-fetish help people to adopt a plurality of new stances toward software and code? (Jeremy Douglass)
If C is an abstraction from the von Neumann architecture, then why not think about how it illuminates the fundamental assumptions of that architecture, rather than about how it hides all of the specifics of each implementation? [(and]) What is a function but precisely the fetish that represents an action as the magically complete and concrete result? (Evan Buswell)
Where might we situate the emergence of close analyses of technology in relationship to our history, especially in its relationship to the development of specific technologies? [(and)] Do we begin to see code (and technology) as a relatively unified concrete object of knowledge as it becomes less diverse? (David Shepard)
Perhaps we can promote the positive, spectral aspects of code - "unleash the unexplainable" - to build interest, resulting in a better understanding of systems that drive most of our daily routine? (Craig Dietrich)
What is the subject that is constituted through code? (Frederica Frabetti)
If the CCS Working Group was a quest (as Weeks 2 and 3 might lead one to think), then Week 4 was like a ledge we found to rest on after battling to map and remap the practices and theories that define this burgeoning discipline. In this respite are considerations of how we interpret code and how we are interpolated by code. The logic of fetishism encouraged thoughtful dialogue and required participants to explore what is concealed by our ideological and disciplinary assumptions about code. What surfaced during the course of this discussion was pleasure. As Craig Dietrich mentioned, "Whether fetishizing the medium or seeing magic in the work of others, the net effect ... is excitement." The joy we obtain through the process of watching an idea materialize and then working to understand how that materialization took place is, I would wager, a shared feeling among the professions represented in our CCS discussions. Literary scholars, rhetoricians, programmers, anthropologists, artists, activists, etc.,-- perhaps one of our most shared characteristics is the pleasure we take in discovery, in the process from unknown to known, and in the actions we take that make this process possible.
By drawing attention to the ways in which we fetishize code, Chun compelled CCS participants to interrogate our own enjoyment, and through this interrogation, to recognize the historical embeddedness of both our desire and our code. Such readings highlight a productive tension between the individual and idiosyncratic (see Jeremy Douglass' comment on // this program spits out "hello world") and the shared assumptions or rules governing a social body (see Mark Marino's response, returning us to a conversation from an about code "in the wild" conversation in from Week 2). Moreover, they raise productive questions about subjectivity, production, and power. Although the questions (Who is writing? For whom? To what end?) may appear simple, the relationships they foreground are often incredibly rich and complex (such as the emergence of structured programming that Chun historicizes and interprets in her chapter).
Returning to the tale of the trackpad, I would like to suggest that in addition to being an amusing story of technological literacy (or lack thereof), it also illuminates the move whereby the recognition of code as code is deferred through ritual, or through a reprogramming of human practice. In "Traumas of Code" Hayles asserts that "trauma has structural affinities with code" because "code, performing as the interface between humans and programmable media, functions in the contemporary cultural Imaginary as the shadowy double of the human-only language inflected and infected by its hidden presence" (Hayles 157). Hayles' proposal of an analogous relationship between the structural elements of code and trauma implies that we should read my trackpad anecdote as a case of acting out - the perpetuation of an action through ritualization in order to suspend resolution in an ever-receding future. However, the shift from Hayles' estimation of code as "hidden presence" to Chun's "simultaneous presence and non-presence of code" indicates another, perhaps more productive interpretation.
Chun's characterization of code as vapory implies an in-betweenness or a state of constant flux. As CCS participants, we are aware of this flux because it is what our critiques aim at pinning at down, possibly accounting for why such critiques produce at least as many worthy questions as they do assertions. However, Chun's critique also opens up a space for us to consider how our bodies register the conflict of a functional language that is always shifting in and out of conscious perception. Rather than simply rendering us all cyborgs, how does code transform the very human language with which we critique it? And how often do we simply surrender to rituals to protect us from sourcery?
Hayles, N. Katherine. "Traumas of Code." Critical Inquiry, 33 (Autumn 2006): 136-157.
Heidegger, Martin. "The Question Concerning Technology," Basic Writings Ed. David Krell. New York: HarperCollins Publishers, 1993: 310-341.
Thrift, Nigel. "Remembering the Technological Unconscious by Foregrounding Knowledges of Position." Environment and Planning D: Society and Space, 22.1 (2004): 175-190.