James E. Dobson Rena J. Mosteirin


BEFORE YOU START TO READ THIS BOOK, take this moment to think about making a donation to punctum books, an in- dependent non-profit press,


If you’re reading the e-book, you can click on the image below to go directly to our donations site. Any amount, no matter the size, is appreciated and will help us to keep our ship of fools afloat. Contributions from dedicated readers will also help us to keep our commons open and to culti- vate new work that can’t find a welcoming port elsewhere. Our adventure is not possible without your support.

Vive la Open Access.

Figure 1. Hieronymus Bosch, Ship of Fools (1490-1500)

MOONBIT. Copyright © 2019 by James E. Dobson & Rena J. Mosteirin. This work carries a Crea- tive Commons By-Nc-sa 4.0 International license, which means that you are free to copy and redistribute the material in any medium or format, and you may also remix, transform and build upon the material, as long as you clearly attribute the work to the authors (but not ina way that suggests the authors or punctum books endorses you and your work), you do not use this work for commercial gain in any form whatsoever, and that for any remixing and trans- formation, you distribute your rebuild under the same license. licenses/by-nc-sa/4.0/

First published in 2019 by punctum books, Earth, Milky Way.

ISBN-13: 978-1-950192-33-5 (print) ISBN-13: 978-1-950192-34-2 (ePDF)

DOI: 10.21983/P3.0260.1.00

LCCN: 9781950192335 Library of Congress Cataloging Data is available from the Library of Congress

Book design: Vincent W.J. van Gerven Oei

Cover image: Apollo 11 Mission image CSM over the Sea of Tranquility (AS11-37-5448, July 20, 1969) The Apollo 11 Command and Service Modules (CSM) (tiny dot near quarter-sized crater, center), with astronaut Michael Collins, command module pilot, aboard. The view overlooking the western Sea of Tranquility was photographed from the Lunar Module (LM). Astronauts Neil A. Armstrong, commander, and Edwin E. Aldrin Jr., lunar module pilot, manned the LM and made their historic lunar landing on July 20, 1969. Coordinates of the center of the terrain in the photograph are 18.5 degrees longitude and .5 degrees north latitude.


James E. Dobson Rena J. Mosteirin


Rooooo Introduction

Roooo1 Code Hermeneutics

Roooo2 The AGC and Computing in the 1960s

Moonbit: Erasure Poems Derived from Apollo 11 Source Code Part One: Comanche


Pinball Noun Tables

Of Next Burn

Alarm and Abort

To Load into Smode Waitlist


Fresh Start

Star Tables

Time of Free Fall

Jet Selection Logic Lunar and Solar Ephemerides Subroutines Erasable Assignments Erasable Assignments 2.0 Antenna

Part Two: 64 Found Bits (8 poems made of 8 octets of erasure)










Part Three: Moonbit: The 64 Bit Poem Breakdown


Body Attitude

Conic Subroutines

Stable Orbit

Planetary Inertial Orientation Pad


File of the Same Name

Rooo003 Code Poetics Roooo4 Cold War Code and the Doubled Discourse of Programming



103 104 105 107 108 109 144






We would like to thank Don Eyles, who answered several questions via email and who generously showed us his printed copy of the AGC code and parts of the hardware at a reading from Sunburst and Luminary at the MIT Museum in March of 2018.

We presented material from this book at two conferences, HaPoP in March of 2018 at University of Oxford and SIGCIS/SHOT in November 2018 in St. Louis, Missouri. We would like to thank the organizers, participants, and audience members at these two events for including us and for many very helpful questions and suggestions.

Ronald S. Burkey, creator of the Virtual AGC project, curator of a wealth of information about the Apollo computers, and author of numerous soft- ware components, including yaYUL and yaAGC, answered several questions and supplied one of the high-resolution scanned images included in this book. Without Ron’s work and ongoing maintenance and stewardship, the AGC code would remain locked in paper and the subject of only historical inquiry. Thank you also to Jim Lawton for his work on the iBiblio website and archive.

Rena J. Mosteirin wishes to express her gratitude to her mentors from the Bennington Writing Seminars, where she developed many of the ideas that came to fruition in this book: Mark Wunderlich, April Bernard, Major Jackson, and Carmen Giménez-Smith.

We have been consistently inspired by the work that punctum books makes possible and we offer our warmest thanks to Eileen Joy and Vincent W.J. van Gerven 0ei.

Dedicated to William W. Cook, teacher and poet.


“I dare to imagine the general public learning how to write code. I do not mean that knowledge of programming should be elevated to the ranks of the other subjects that form basic literacy: languages, literature, history, psychology, sociology, economics, the basics

of science and mathematics. I mean it the other way around. What I hope is that those with knowledge of humanities will break

into the closed society where code gets written: invade it.” —Ellen Ullman, Life in Code

This collaboratively authored work, much like the object that has inspired it, is nonlinear and modular. It has been compiled together from several smaller component parts. We invite you to read this book accordingly. We have provided a series of experimental readings just a few of what we be- lieve to be the numerous explorations of the creative possibilities found within the confines of a rigidly constructed formal language that was once used to facilitate the breaking of existing spatial boundaries. We intend each section to expose new horizons of interpretation and exploration for understanding the poetics of code.

Throughout this book, we seek to show that software, or more specifi- cally computer code, in excess of its bare functionality or its use value as an instrument to achieve some planned and programmed goal, also has nu- merous aesthetic properties and creative features. The aesthetic features of computer code often characterized by a rigidly formal, restricted syn- tax, and numerous paralinguistic dimensions sometimes have a supple- mental character; they appear, at times, almost ornamental in their sheer excess beyond the functional elements and programmed goals. At other times, these features are an intrinsic and necessary part of the code. We believe that these special properties of computer code make possible im- aginative uses or misuses by its human programmers and that these prop- erties and features justify our exuberant readings, misreadings, transla- tions, and appropriations.

At its base, this book is a poetic and philosophical meditation on the idea of computer code and the affordances and limitations of a language that is machine-oriented yet human-authored. The ordered instructions of this technological language work overtime to keep at bay the disorder of the world and the imprecision found in human language and thought. At the same time, this book is also a work of cultural analysis that exam- ines what we will show to be the intersections of several distinct discours- es that are all registered in this now obsolete and obscure computer lan- guage: the dreams and aspirations of 1960s computer and space science, the Cold War ideologies that enabled these technologies, the knowledge gained from the application of these technologies that was then used to advance and exercise imperial military power, and the traces of a coun- ter-cultural language that emerged to supplement and at times resist com- ponents of the sparse, stripped-down syntax of these other discourses. Re- covering, uncovering, and decoding these imbricated discourses requires


the resources of multiple fields and approaches methods both specialized and radically undisciplined.

Together, we take up a fascinating and now monumentally important historical source text for our critical and creative readings: the source code for the guidance computer that powered both the command and lunar modules for the Apollo Project, and specifically the version or edition of the code as used in the legendary Apollo 11 mission from July 16 to July 24 1969. This book appears during the fiftieth anniversary of this historic flight and we want to use this moment and our work to commemorate and critique this scientific and cultural event. This code was one of the technologies that made space travel possible; it would not be wrong to say that we wrote our way to the Moon. The Apollo Project, with its grand ambitions and aims, has inspired countless students, scientists, and engineers to dream big, to find and follow their vocations into the sciences and the arts, and to launch their own large-scale imaginative projects. Yet one of the most crucial newly developed technologies that enabled the astronauts to land on and return from the Moon, the digital computer that provided these astronauts with guidance data and assisted in the control of the Lunar and Command Module, has remained somewhat cloaked in obscurity. Unavailable and un- interpretable to the larger public, the text of the code powering this revo- lutionary computer remained locked within what we might call its base or bare functionality.

Each section of this book highlights and illuminates different aspects and dimensions of the Apollo Guidance Computer (AGC) code and the cultur- al moment that enabled its construction. We are producing code commen- tary remarking and remixing the code. We intend no single account of the code to be definitive; our purpose in presenting critical commentaries alongside poetry is to interrupt the desire to fix and re-instrumentalize our source text. Instrumentalization, in part, involves the flattening of a tech- nology into a mere tool and the privileging of what we might term the an- thropological account of a technology as a means by which to accomplish some goal. In reading an object that one might assume to be the province of one culture through the tools and methodologies of another, we want to show that this division, the now entrenched separation of the sciences and the humanities, itself has already been called into question by the in-


vention of code.‘ Proceeding from here, we provide wide ranging readings, responses, and interpretations of the code that we believe will aid our read- ers in thinking broadly about exploration, collaboration, and computation. Moonbit will not get you to the Moon, but seeks to re-claim the text that did this, as a site for artistic exploration.

It is in this spirit that we write this book as a collaborative project. In- spired by the collective work of over four hundred programmers, writers, engineers, project managers, and others who worked on the various Apollo 11 digital computer systems both hardware and software not to mention the hundreds of thousands participating in the larger 1960s space program itself, we “compiled” this book from a critical reading and what could be called a deformation of its source text into a collection of poems and ex- pansive commentary. We would like to think of this project as a set of re- marks here we use remarks in order to riff on the term for the existing formalized commentary supplied by the original authors of the code and included within the body of the code—on the code that frame and elaborate the meaning of the code at its point of origin in 1969, its longer historical context of the development of computing and scientific exploration, and the code’s meaning for our present moment.

The authors of another study and exploration of “old” and obsolete code, 10 PRINT CHR$(205.5+RND(1)); : GOTO 10, faced a much larger task than ours at present: convincing their readers that their singular titular line of BASIC code for the Commodore 64, a popular home computer produced during the 1980s, was an important cultural artifact and one worth engaging with in the present and that their interpretations and readings had value for soft- ware studies. They write:

The subject of this book a one-line program for a thirty-year-old mi- crocomputer may strike some as unusual and esoteric at best, indul- gent and perverse at worst. But this treatment of 10 PRINT was under- taken to offer lessons for the study of digital media more broadly. If they

1 In “New Methods for Humanities Research,” his 2005 Lyman Award Lecture, prominent digital humanities scholar John Unsworth cites Bill Wulf, a former president of the National Academy of Engineering, as arguing that “computer science should really be considered one of the humanities, since the humanities deal with artifacts produced by human beings, and computers (and their software) are artifacts produced by human beings,”


prove persuasive, these arguments will have implications for the inter- pretation of software of all kinds.?

The examination of obsolete code, whether written, modified, and used by hundreds of thousands of hobbyist home computer owners or developed in secret for the US nationalist project of space exploration, brings elements of the past into the present and reveals how this obscure computational past might, to riff on William Faulkner, not even be past. We believe that the AGC code is of as much historical and cultural interest, if not more, as the memoirs, recordings, and documents that serve to record and shape our understanding of the inception and development of the US space program.

Source code appears throughout this book, sometimes with extensive commentary that draws out the implications, assumptions, and desires of the authors, and other times lines of code appear as suggestions or provoca- tions. We do not expect the reader to be familiar with the specific language used or to have studied computer science. We present code as an interpret- able object. This is because this particular code text, while restricted to the confines of the fixed format dictated by 1960s coding standards and require- ments, contains a rich set of meta-commentary that explains as it codifies - that attempts to account, in a series of remarks, for the many decisions made and choices selected within the code. Code, it might surprise you to learn, is not written just for a computer; code, as we will show, has many audiences and can be shaped into several different forms. Code is not just what is executed by the computer, but a language, a discourse, with crea- tive and functional possibilities. Contrary to the common perception of pro- gramming, code is not just a set of instructions, it is not just math. Even in the earliest and simplest of computer languages, written code is frequently imaginative and has the capacity to be wildly playful. Code contains within it a poetics of its very own. There is an aesthetics to be found within the construction of code but these aesthetic features sometimes exceed their functional value. We believe the AGC code to be truly remarkable code.

This book, in part, seeks to provide an introduction to the theory and practice of critical code studies. We seek to outline a more capacious ver- sion of critical code studies that takes up all manner of imaginative de- codings and recodings of our object of analysis. In introducing some of the

2 Nick Montfort et al., 10 PRINT CHR$(205.5+RND(1)); : GOTO 10 (Cambridge: MIT Press, 2013), 5.


major existing approaches to the study of code and culture, we attempt to provide multiple readings of the source code along with an explanation and theorization of the way in which the Apollo Guidance Computer code works, as both a computational and a cultural text. We tend, however, to privilege the cultural rather than technical meanings of the code as we unpack, de- form, and explicate. There are a number of existing accounts of the AGC hardware and software and while we will explore some of the functional purposes of this “antique” code, we are finally more interested in the way in which the code can become meaningful to its human readers. This is to say that we believe the code makes and contains interesting cultural com- mentary that we can read in relation to the historical moment in which the code was developed and used.

We draw out buried meaning and recode what was punched out through several interpretive and creative methods, including erasure. The AGC code provides rich source material that is about motion as much as it is about communication complete with scatological jokes in the commentary. This code put people on the Moon and continues to inspire discovery. Era- sure poetry, like the source language that it borrows from, offers itself as a way to memorialize or monumentalize while also making something new. The erasure method begins with a complete source text really any sort of object and removes much of it, creating a new text, a poem entirely wrought from some other primary textual source. Jen Bervin’s Nets takes Shakespeare’s sonnets as its source and erases most of the words, carving entirely new poems out of canonical literature. In contrast, Tom Phillips, in his art book A Humument, takes an unknown Victorian novel, A Human Document by W.H. Mallock, and erases most of it. Phillips makes each page into an original work of art, with only a few of Mallock’s original words re- maining. M. NourbeSe Phillip’s Zong! makes a coherent cacophony of what remains from a massacre of one hundred and fifty slaves who were pushed off the slave ship Zong, so that the Zong’s investors could re-coup what they lost in a failed venture in the form of insurance money. This case left behind a legal legacy of barely five hundred words. Phillip’s book-length Zong! poem gives voice to those massacred people and distressingly, but cor- rectly, offers the reader no consolation.?

3 Jen Bervin, Nets (Brooklyn: Ugly Duckling Presse, 2004); Tom Phillips, AHumument (Lon- don: Thames and Hudson, 1980); M. NourbeSe Philip, Zong! (Middletown: Wesleyan Univer-


Poems about space travel crave white space on the page. Here the white space represents the unknown cosmos or white light from the stars or per- haps the white face of the Moon itself. Erasure creates white spaces. Era- sure creates room to breathe and space to think by finding holes within the source text or creating holes by erasing existing marks and larger textual structures. It navigates through these gaps, found or created, within the source text to bring something new into being. This debris may be of use. While there are computational methods for automatically producing era- sure poetry, the poems in this book follow no program.‘ They are human responses to code written by other humans. As William W. Cook argues of Frederick Douglass’s understanding of learning to write by “writing in the spaces left” in a source text: “In the spaces left he finds those uninscribed topoi necessary to his own creation. He writes a hand similar to, but not identical with, that of his model preparatory to taking full control of the text itself. Imitation and repetition lead here to creativity and liberation.”5 The AGC code itself contains multiple languages, multiple worlds. It con- tains subroutines to alter our orientation, to translate our coordinates, to alter its internal representation of space in terms of the Earth and the Moon. Erasure, for Brian McHale, engages in a cycle of “making and un- making” that, in the case of James Merrill’s work, “structure (and decon- struct) the world, or rather the worlds in the plural.”* Applied to this multi- ple-worlded text at the limits of modernity, erasure reinserts the hand into the machine to liberate the poet and this text and in the process, destabi- lize the inscribed formal relations among the represented bodies.

The four hundred programmers and engineers working on the Apollo Guidance Computer were employed by the Draper Laboratories, later the MIT Instrumental Lab, in Cambridge, Massachusetts. The code was not devel- oped in isolation; it builds upon prior knowledge and expertise, collabora-

sity Press, 2011).

4 See, for example, The Deletionist program created and theorized by Amaranth Borsuk, Jesper Juul, and Nick Montfort, “Opening a Worl in the World Wide Web: The Aesthetics and Poetics of Deletionism,” NMC: Media-N 11, no. 4 (2015), http://median.newmediacaucus. org/the_aesthetics_of_erasure/opening-a-worl-in-the-world-wide-web-the-aesthetics- and-poetics-of-deletionism/.

5 William W. Cook, “Writing in the Spaces Left,” College Composition and Communication 44, no. 1 (1993): 9-25, at 16.

6 Brian McHale, “Poetry under Erasure,” in Theory Into Poetry: New Approaches to the Lyric, eds. Eva Muller-Zettelmann and Margarete Rubik (New York: Rodopi, 2005), 295.


tors within other organizations and departments, and the contributions of consultants and industry partners. These programmers and engineers de- veloped the code with instructions from NASA, editing and debugging from Cambridge, while astronauts departed from Earth with their code, their creation, within the lunar and control modules.

The advent of the digital computers placed in the Apollo Lunar Module marked an incredibly important development in the history of digital com- puting and space flight. In the past few years there has been an increasing amount of interest in these systems and the people behind the development of this early code. Images of the printed code were scanned and uploaded to the information sharing site iBiblio and optical character recognition (OCR) software (along with some manual editing) was used to render these images of printed text legible in digital form. The archives of the code ena- bled hobbyists and space enthusiasts to explore and play with the AGC code but it remained difficult for browsers to understand the larger code project in its entirety until the text of the code was made available in a new form. It was, then, in 2016 that an intern at MIT uploaded the AGC code to the code repository Github, enabling global and easy access to the code along with the collaborative editing, commentary, and revision tracking system pro- vided by the site. In the process of moving the code into Github, the code was segmented into separate files and presented in a form that would work with the Github conventions for displaying code, including the transfor- mation of certain code features that formerly belonged in fixed positions into a contemporary, less structured form.

While the conversion of the AGC code into Github drew our attention to this code, our primary driver for exploring the code was the growing atten- tion to the work of one particular MIT Instrumental Lab staff member that coincided with the Github “publication” of the Apollo code. In “compiling” our readings and responses into this book we seek, above all, to recognize and acknowledge the contributions of Margaret Hamilton, lead program- mer on the Apollo Guidance Computer project. Hamilton was one of the few women working in the nascent field of computer engineering and the only female senior staff member. In November 2016, President Obama awarded Margaret Hamilton the Presidential Medal of Freedom. In his citation, Oba- ma wrote of her many contributions, all of which were first imagined and explored in the text of the AGC code examined by this book: “Hamilton con- tributed to concepts of asynchronous software, priority scheduling and pri- ority displays, and human-in-the-loop decision capability, which set the


foundation for modern, ultra-reliable software design and engineering.” Hamilton’s work on the Apollo project and that of many others helped to establish the field of software engineering and legitimized new discursive practices. Her work and imagination inspires our own flights of fancy as we produce numerous readings of the code that she committed to the Apollo


7 President Barack Obama’s citation reads as follows: “Margaret H. Hamilton led the team that created the on-board flight software for NASA’s Apollo command modules and lunar modules. A mathematician and computer scientist who started her own software com- pany, Hamilton contributed to concepts of asynchronous software, priority scheduling and priority displays, and human-in-the-loop decision capability, which set the foun- dation for modern, ultra-reliable software design and engineering.” Office of the Press Secretary, “President Obama Names Recipients of the Presidential Medal of Freedom,” The White House, November 16, 2016, fice/2016/11/16/president-obama-names-recipients-presidential-medal-freedom.



Code Hermeneutics

“The reasoning behind this part is involved.” AGC Source Code

The Apollo Guidance Computer (AGC) code was primarily designed to be as- sembled and executed, not read and explored on the page. For those users of the several software emulators of the AGC, this is still an executable body of code. Yet this collection of code, like almost all code, is also a discur- sive object that registers and contains within its symbols, language, and self-understanding traces of its authorship, of its moment of production. Code, despite our ready assumptions of it as a set of concise, minimal, and utilitarian instructions, is an interpretable text. Code is a particular kind of polyvocal textual object. It is written for and addresses the particular software and hardware that define, to borrow a phrase from literary stud- ies, what we might call its ideal reader. This reader is a particular platform with all its attendant affordances and limitations. Code, depending on the language and methods of abstraction, may very well run on other platforms without the work of porting, the translation of platform-specific code. Al- gorithms, of course, are generally platform-agnostic and can be reimple- mented with relative ease. Code speaks, as it were, to multiple audiences and in multiple voices. There are multiple active discourses in much com- puter code and the AGC code provides contemporary readers with a particu- larly interesting site for examining the co-existence of these discourses. But what sort of object is the AGC code? What sort of reading practices do we need to disentangle these discourses and interpret them? Should we con- sider code a text? Computer code, after all, is not— despite the way in which it is usually imagined by the public constructed in ceaseless strings of 1s and os, but instead written using a standardized lexicon of textual signifi- ers, supplemented with some language-specific syntax. It is usually quite modular and organized into readable chunks with spacing and indentation used to enable comprehension. Code is almost always written and edited by humans. Almost every programming language borrows the major compo- nents of its syntax from a source “natural” language (this has been typical- ly English) and programmers make logical and indeed creative and imagi- native use of this language within both their code and their commentary. Certainly, in the hands of cultural studies scholars, almost any object or action can be read as a discursively constructed text, from fashion to dance, from television programs to the Sony Walkman. Software, and espe- cially computer code, can be understood as a cultural text because, as this book demonstrates, these texts are always constructed within the cultural constraints of the historical moment in which they were created and used. These constraints include, but are not limited to, the capabilities of particu-


lar hardware and supporting software libraries, major programming para- digms and languages, the so-called best practices of various programming communities, previously established methods and algorithms, the choices made by the few computer corporations that control the digital computer market, and the market available and constructed for the software product. For computational critic and theorist David Berry, code is a particularly im- portant type of cultural text, because it simultaneously participates in sev- eral different registers. “Code,” Berry writes, “needs to be approached in its multiplicity, that is, asa literature, a mechanism, a spatial form (organisa- tion), and as a repository of social norms, values, patterns and processes.”* Software, as the packaged and typically feature-frozen version of a selected configuration of code, touches more of these discourses and is under more of these constraints than the source code that typically remains hidden or obscured through the process by which it is compiled into machine execut- able software. But both software and source code register these frequently conflicting aspects of culture.

As a textually mediated mode of explanation and instruction written by a community of programmers and hackers, code shares much with other forms of textual expression, including literary texts. One powerful method by which we can examine the Apollo Guidance Computer code is through what literary scholar and theorist Caroline Levine calls the “new formal- ism.” Levine’s understanding of formalism is not limited just to the tradi- tional aesthetic elements of formalism as used for decades within literary studies the familiar practice of close reading that prompts the reader to cast her eye to language, lingering and dwelling on the appearance and significance of the words on the page but also to a theoretically informed account of what Levine calls the “ordering principles.” She uses this no- tion of ordering in her gloss of this updated or “new” formalist method that examines, broadly, “an arrangement of elements an ordering, pattern- ing, or shaping.”? Levine’s version of formalism pays close attention to the affordances of both literary, textual, and social structures often these social structures are external to the text and understands these various forms as not isolated phenomena but co-existing and in an informing re-

1 David M. Berry, The Philosophy of Software Code and Mediation in the Digital Age (New York: Palgrave, 2011), 36.

2 Caroline Levine, Forms: Whole, Rhythm, Hierarchy, Network (Princeton: Princeton Uni- versity Press, 2015), 3.


lation to each other. This is to say that the aesthetic forms used within any particular text can have political implications and that political forms may contain within them an aesthetic element.

In the theoretically informed readings of the AGC code that follow, the question of relation between social and aesthetic forms will continually re- appear. In order to understand the AGC code and the multiple possible mean- ings produced and found within the code, we will have to shift the frame back and forth between different hermeneutical registers. This reading practice, like the code itself, might be thought of as modular and extensible.

The framework of the emergent field of critical code studies (CCS) pro- vides, through the tacit agreement of the different possible critical per- spectives, some possible methods through which we can frame and in- terpret the code. The close readings of code that follow will unpack and explain the purpose and aspirations of the displayed code segments. In so doing, the AGC software becomes visible as an important and readable cul- tural artifact and maybe even a work of art.

Computer software, cultural critic and theorist Lev Manovich tells us, is new media. Scholars working in the emergent field of software studies bring a range of critical resources, including ideological critique, formal analysis, and aesthetic criteria to bear on the design, construction, and everyday use of computer software. In several recent books, Manovich, one of the primary figures involved in the creation of software studies, asks us to take seriously the study of software, because software “mediates peo- ple’s interfaces with media and other people.”? More and more, our every- day interaction with both local and global news, weather reports, text, au- dio, and video messaging, music, movies, games, directions, and access to knowledge itself is fully mediated by an array of personal digital devices and the software that presents and shapes these services and experiences. Software, in short, is culture. While there are different kinds of software, and many different ways of studying software, Manovich examines the use of media software. He defends his decision to study the mostly commercial creative media software used by cultural workers by pointing to the large and mostly anonymous user base of these packages. He argues that he wants to analyze what he calls “mainstream cultural practices”* instead of the

3 Lev Manovich, Software Takes Command (New York: Bloomsbury, 2013), 29. 4 Ibid., 31.


exception: those developing software or those involved in modifying or tinkering with existing software. This approach is roughly analogous to the arguments made by some scholars of popular culture.

While Manovich focuses on the way in which users interact with soft- ware, in particular those software packages that are used to create and ac- cess new media, other scholars have begun investigating the internals of software, the code that enables software to produce these functions and interfaces. Critical code studies (CCS) is an emergent approach to the study of software and the code that makes up this software that originates in the critical approaches offered by the field of cultural studies. Proponents of CCS argue that we can read code as an object for critical analysis; in the way in which cultural studies describes images and objects as a text, code may also be understood as a text.

David M. Berry makes an important distinction between code and soft- ware. He uses the term code

to refer to the textual and social practices of source code writing, test- ing, and distribution. In contrast ‘software’ (as prescriptive code) will refer to the object code, that is, code that has been compiled into an ex- ecutable format, which includes final software products, such as oper- ating systems, applications or fixed products of code such as Photoshop, Word and Excel.

Berry’s distinction depends on the division between executable, ma- chine-readable software or compiled code and the source code that gen- erates such software. This division is especially important to the commer- cial packages Berry mentions, Adobe’s Photoshop and Microsoft’s Word and Excel. These complex software packages are protected, controlled-access products. The code remains proprietary, a corporate secret, in order for the vendor Adobe and Microsoft in the case of the packages mentioned by Ber- ry to sell access and, increasingly, automatically expiring subscriptions for the right to use the software products.

If, for David Berry, we should read code because code can give us insight into the software creation process, for Mark C. Marino, code is an important text in need of interrogation and critique because it offers a site for not

5 Berry, The Philosophy of Software Code and Mediation in the Digital Age, 64-65.


just the analysis of software culture, but for the larger project of cultural analysis. Marino argues that code is a layer of discourse presumably he means by this that code exists in some relation to other forms of cultural discourse loaded with significance. It is a particular kind of cultural text, one “with connotations that are in conversation with its functioning.’® By this Marino means that the language that makes code work the in- structions, functions, and assignments exceeds its instrumental value. Descriptive language - in his essay he highlights the naming of variables - makes something happen while also providing another type of meaning that is in excess of its functional value. While Marino’s variable names are an example of natural language typically they encode meaning within their abstraction as pointers to data by naming the pointer itself —within code, the particular programmatic choices including spacing and even the organization of the code are subject to this form of critique. Extending the scope of CCS beyond the formal readings of source code, Marino claims that critical code studies “explores existing programming paradigms, but it also questions the choices that were made, examining among other aspects the underlying assumptions, models of the world, and constraints (whether technological or social) that helped shape the code.”” Scholars making use of CCS who work within cultural studies frame code as just another cultur- al, i.e., social text capable of revealing aspects of the culture that informed the writing of the code.

Because of the above issues involving the intersection of familiar or ordinary natural language appearing within code, the majority of debates within critical code studies and software studies has tended to discuss the philosophical nature of code and the relation between code, language, and writing. Alexander Galloway argues that code is different from writing, from language, because, in his account, code is a special type of language that he calls hyperlinguistic: “Code is a language, but a very special kind of language. Code is the only language that is executable.”® Galloway pro- vocatively describes code as “the first language that actually does what it

6 Mark C. Marino, “Why We Must Read the Code: The Science Wars, Episode IV.” In Debates in the Digital Humanities, eds. Matthew K. Gold and Lauren F. Klein (Minneapolis: University of Minnesota Press, 2016), 139.

7 Ibid., 140.

8 Alexander R. Galloway, Protocol: How Control Exists after Decentralization (Cambridge: MIT Press, 2004), 165.


says itis a machine for converting meaning into action.”® Language, one might argue contra Galloway’s assertation, can do things, but he wants to make a distinction within code by introducing what he calls an executable state to his understanding of language:

Code has a semantic meaning, but it also has an enactment of meaning. Thus, while natural languages such as English or Latin only have a leg- ible state, code has both a legible and an executable state. In this way, code is the summation of language plus an executable metalayer that encapsulates that language.*°

Code, of course, does not always do exactly what it says it will do —it is in- terpreted, by a compiler or interpreter, and the meaning of the code might not be the same meaning as the execution. Galloway concentrates mostly on compiled languages such as C and C++, in which the code is transformed into executable instructions by a compiler. Compilers (usually) create ob- ject code or bytecode, an essentially lower-level set of instructions that are optimized for system-specific hardware, including central processing units (CPUs) or virtualized systems (in the case of Java).** The notion of code as doing what it says becomes more complicated and less and less true as we add layers of abstraction and modularity. Because of Galloway’s empha- sis on compiled rather than interpreted languages, he tends to treat code as separable from its instruction. Interpreted languages are one step clos- er to programmers than the compiled languages critiqued by Galloway; the code is interpreted and executed by the interpreter as written, in its ini- tial state. Interpreted languages are also subject to the critique of complex systems that will follow, but in general interpreted languages stay within what Galloway terms a legible state. Highly specialized and opaque code, as this book demonstrates, needs the supplement of natural language to make its meaning legible for human readers. This supplement renders the text of

9 Ibid., 165-66.

10 Ibid., 166.

14 The target, by which we mean an audience that must be addressed and included for compiled code. The target for most compiled “C” code on a modern Linux system is an optimized and dynamic stack of libraries. This target platform is described formally by the operating system as such: “ELF 64-bit LSB executable, x86-64, version 4 (SYSV), dynamical- ly linked (uses shared libs), for GNU/Linux 2.6.18, stripped.”


the AGC code a complex configuration of writing, a space-age entanglement of meaning making that invites the full resources of critical analysis to unpack and explore.

John Cayley, who helped inaugurate critical code studies and code poet- ics with his essay “The Code is not the Text (unless it is the Text),” helps us to think through this complex problem of the audience for code:

If a codework text, however mutually contaminated, is read primarily as the language displayed on a screen then its address is simplified. It is addressed to a human reader who is implicitly asked to assimilate the code as part of natural language. This reading simplifies the intrinsi- cally complex address of writing in programmable media. At the very least, for example, composed code is addressed to a processor, perhaps also addressed to specific human readers (those who are able to ‘crack’ or ‘hack’ it); while the text on the screen is simultaneously? asynchro- nously? addressed to human readers generally. Complexities of address should not be bracketed within a would-be creolized language of the new media utopia.*?

Cayley is interested in a possible poetics of code and locates his investment in complicating the lines between code and text in his naming of the text of code “codework.” Cayley positions his codework as addressed simultane- ously to the machine and the human reader. Doing so enables him to resist the separation between what appears on a screen or device and the code that brings this digital appearance into being. For Cayley, the audience of code must always include the possibility of a human reader.

The question of audience and code legibility persists within CCS. N. Kath- erine Hayles follows Galloway’s understanding of code as distinct from the natural language associated with writing because of its function and its primary audience. She argues that despite the possibility of human readers, code is written primarily for machines, for a computer:

Although code originates with human writers and readers, once entered into the machine it has as its primary reader the machine itself. Before any screen display accessible to humans can be generated, the machine must first read the code and use its instructions to write messages hu-

12 John Cayley, “The Code Is Not the Text (Unless It Is the Text),” Electronic Book Review, September 10, 2002,


mans can read. Regardless of what humans think of a piece of code, the machine is the final arbiter of whether the code is intelligible.*3

This difference is what enables her to construct a successive genealogy for “the three major systems for creating signification”: “In the progression from speech to writing to code, each successor regime reinterprets the sys- tem(s) that came before, inscribing prior values into its own dynamics.’?5 For Hayles, this process of reinterpretation does not necessarily obsolete the prior regime, but it does produce extensions and alterations that fun- damentally exceed the capacity of the previous system to describe the new world inaugurated by the new regime. “One of Derrida’s critical points,” Hayles argues, “is that writing exceeds speech and cannot simply be con- ceptualized as speech’s written form. Similarly, I will argue that code ex- ceeds both writing and speech, having characteristics that appear in nei- ther of these legacy systems.”** Hayles’s use of “legacy system” produces a shift, but it is not as dramatic of an obsoleting shift as it sounds —she calls speech and writing “vital partners on many levels of scale in the evolution of complexity.”*7

In a later work, Hayles doubles down on her argument that code must always be considered executable and that is always addressed to a specific interpretive community, the machine:

If the transition from handwriting to typewriting introduced a tectonic shift in discourse networks, as Friedrich Kittler (1992) has argued, the couple of human institution and machine logic leads to specificities quite different in their effects from those mobilized by print. 0n the hu- man side, the requirement to write executable code means that every command must be explicitly stated in the proper form. One must there- fore be very clear about what one wants the machine to do.*®

13 N. Katherine Hayles, My Mother Was a Computer: Digital Subjects and Literary Texts (Chica- go: University of Chicago Press, 2005), 50.

14 Ibid., 39.

15 Ibid.

16 Ibid., 4o.

17 Ibid., 55.

18 N. Katherine Hayles, How We Think: Digital Media and Contemporary Technogenesis (Chi- cago: University of Chicago Press, 2012), 42.


Despite the claims made by Galloway and Hayles, we cannot guarantee that the instructions will be executed as written because of the various levels and layers of abstraction involved in computing. The expected execution of even compiled code can be altered. Depending on the language and sys- tem used, there are multiple layers of interpretation and transformation that take place between the writer of code and the final execution of in- structions. Modern computing systems are constructed from modular com- ponents, both software and hardware, and these components continually