Code—the written programming instructions that direct computers—is everywhere. It’s in our cars, our pockets, and it sits behind most aspects of our lives. But code remains largely unexamined. Mark C. Marino’s recent book, Critical Code Studies, takes its place in the emerging field of Software Studies and a growing discourse around the examination of software and code within the humanities. Building on the work presented in 10 PRINT CHR$(205.5+RND(1)); : GOTO 10 (Montfort et al. 2014), Critical Code Studies explores the approaches and techniques scholars can use to critically examine computer code and what it means within a broader cultural context.
Critical Code Studies defines and explores the nature of code as a symbolic system and the challenges those in the digital humanities face in examining these systems as a text. It is “an approach to code studies that applies critical hermeneutics to the interpretation of computer code, program architecture, and documentation within a sociohistorical context” (Marino 53). One of the key challenges for Critical Code Studies (CCS) is the multifaceted nature of its subject matter. Those practicing CCS must always keep in mind the way that developers, users, hardware, and software interact with the source code they are examining. Code draws its meaning from each facet of its existence—as text, but also as an executed program.
This negotiation between text and program is emphasized in the book’s examination of the Climategate hack. In 2009, hackers “exposed” work-in-progress climate modelling code from the Climate Research Unit of the United Kingdom’s University of East Anglia. The hackers released both the code and the researchers’ emails, with many commentators—like UK politician Lord Lawson and Telegraph writers James Delingpole and Christopher Booker—claiming that this evidence proved climate change was a hoax. Marino’s examination of this event underlines the way in which socio-political contexts can dramatically change the meaning that readers, even technically proficient readers, draw from their examination of code. It also brings into sharp relief the need for scholars that are skilled in the reading and analysis of code in the broader public discourse.
In the modern world, most of us will use software that has largely been developed in places and within cultures outside of our own. Critical Code Studies highlights the importance of examining code and its embedded meanings and values across cultural spheres and national borders. Lawrence Lessig talks about the notion of code as law (Lessig 6), an idea that highlights the fact that code sets the boundaries of what is and is not possible within the digital space. Importantly, those laws reflect the ideologies of the people producing the code and draw boundaries for whomever occupies those spaces. As Marino highlights:
Analyzing culture through code will include discussions of race and ethnicity, gender, sexuality, socioeconomic status, political representation, ideology, et cetera— […] because the walls of a computer do not remove code from the world but encode the world and human biases. (Marino 46)
Economic models, value systems, and cultural assumptions are often encoded into code through a combination of targeted business measures and unconsidered assumptions on the part of the developer. These often-simple programming decisions can bubble up from the code to impact the possible implementations and choices available to the user. Marino explores this topic in chapter five, “FLOW-MATIC,” which highlights the use of US English as the format for most programming languages and the conceptual and functional struggles that arise when developers try to shift this. Marino explores this critical issue through a range of projects aimed at developing programming languages in written languages other than English. His exploration of John Corbett’s Cree# is particularly insightful; it highlights not only the linguistic differences but also the differences in logic structures between English-language programming and those that exist in Cree storytelling.
Elsewhere in Critical Code Studies, Marino demonstrates how the personal beliefs and world views of the programmer manifest themselves in and through their code. Marino makes this case in his analysis of a code segment from a raytracing program, written by the philosopher Friedrich Kittler, and Nick Montfort’s generative poetry project Taroko Gorge. However, Marino’s analysis of Taroko Gorge is not as well developed as it could have been. Within code, there are a range of ways to solve any problem. How a specific developer solves the problem is affected by a range of factors, including the developer’s experience level, background, and what they value as coders. For example, there is an implicit assumption amongst many programmers of the supremacy of concision—expressing solutions in a highly compacted way—over other values, like readability—expressing solutions in a way that is easy to read for other programmers. Marino touches on this issue when highlighting Montfort’s use of single letter variable and function names. When a piece of code uses only single letter variables and function names, other programmers must manually work out what each element of the code does; this can make the code inaccessible for programmers who are less experienced.
While Marino admits that the level of concision in Montfort’s project obfuscates the code’s functionality, making it less readable for others, he doesn’t engage with the deeper cultural aspects of this choice. One of the stated aims of the Taroko Gorge source code was to have others engage with it—to produce their own remixes of the poem generator—causing a strong internal tension between the code’s style and its aims. This tension was not substantially explored or questioned. Instead, Marino privileges the web adaptation of the Taroko Gorge code in HTML and JavaScript, focusing on the higher engagement afforded by approachable programming languages. The push for concision in programming has led to the devaluing of code solutions that are more verbose and easier to read, creating an exclusionary coding culture. Marino calls the practice of deriding other programmers work “encoded chauvinism,” but does not make the connection between these preferences for concision and the exclusionary practices of encoded chauvinism (148). These practices of encoded chauvinism can silence the voices of programmers from diverse and minority backgrounds, particularly when their voices conflict with that of the dominant paradigm.
The book does go into a deeper examination of some of these issues in the fifth chapter, looking at an excerpt of FLOW-MATIC code. FLOW-MATIC is one of the earliest attempts at writing a more universally accessible method for working with computers, and was the foundation for many later programming languages. The chapter explores the issues of technological colonialism, imperialism, and misogyny that permeate code and coding culture. It highlights the issues of access to and accessibility of code and how these elements contribute to a much more complex socio-technological history of code than those who write about it often acknowledge.
One aspect of the book that I find concerning is the dismissal of auto-generated or framework-provided code in meaning-making. Increasingly, when looking at a piece of source code, a percentage of that code may have been provided as part of an existing framework or generated by tools to speed up the human programmer’s workflow. These automatic features are part functional, but they are also part indoctrination, inheriting the human choices of the framework’s developers. While frameworks help standardize the user experience, they also help specific companies build a market dominance; for instance, certification programs train programmers to think like the framework, forcing them to solve problems and articulate their solutions according to a specific development methodology. This further embeds the values and cultural assumptions of the framework or platform within the individual programmer’s own code, even if they do not share cultural contexts, an important missing piece in an otherwise important book.
Critical Code Studies is a pivotal text in the discussion of code and its analysis. It highlights a range of ways to “read” code as a cultural text and emphasizes the need for more studies to take a similar perspective. Critical Code Studies is also a seminal text in that it lays the foundation for the field and encourages the reader to take it further. It lays out a convincing argument that such approaches will only increase in importance in the digital age, that CCS has further untapped potential to expand our understanding of meaning and culture as expressed and explored through code.
Anna Tito is a games software engineer, teaching fellow and PhD Candidate at the University of Canberra. Her research explores the interweaving of games, code, power, culture and relationships.
Critical Code Studies
By Mark C. Marino
Publisher: MIT Press
Hardcover / 288 pages / 2020
ISBN: 978-0-262-04365-6
References
Lessig, Lawrence. 1999. Code: And Other Laws of Cyberspace. New York: Basic Books.
Marino, Mark C. 2020. Critical Code Studies. Software Studies. Cambridge, Massachusetts: MIT Press.
Montfort, Nick, Patsy Baudoin, John Bell, Ian Bogost, Jeremy Douglass, Mark C Marino, Michael Mateas, Casey Reas, Mark Sample, and Noah Vawter. 2014. 10 PRINT CHR $(205.5+ RND (1));: GOTO 10. Software Studies. Cambridge, Massachusetts: MIT Press.
Published on March 24, 2022
