“Hello, World” is one of the first programs that students customarily write in a programming language they are attempting to learn. The program, usually only a few lines of code, causes the computer to output a greeting, as if it were speaking. The LISP (listprocessing language) version of such a program, for example, looks like this:
"你好，世界 "是学生在尝试学习编程语言时最先编写的程序之一。该程序通常只有几行代码，可以让计算机像说话一样输出问候语。例如，这种程序的 LISP（列表处理语言）版本看起来像这样：
(DEFUN HELLO-WORLD ()
(PRINT (LIST 'HELLO 'WORLD))) 

DEFUN defines the function HELLO-WORLD (with no set arguments). As a result, the computer will speak its greeting to the world in our natural language. What could be a more appropriate language for this activity than LISP, a family of algebraic listprocessing languages developed for artificial intelligence (McCarthy 1978)? In this simple program, the computer comes to life in natural language, speaking to us.
DEFUN 定义了函数 HELLO-WORLD（无参数设置）。这样，计算机就能用我们的自然语言向世界问好了。LISP 是为人工智能开发的一系列代数列表处理语言（McCarthy，1978 年），还有什么语言比 LISP 更适合这项活动呢？在这个简单的程序中，计算机用自然语言栩栩如生地与我们对话。

But of course, the computer does not understand what it says. Literally speaking, the computer does not even interpret that code. When the function is called, the computer will print (output) the list of the two atoms (as symbolic units are called in LISP) Hello and World. The single quotation marks tell the computer not to interpret the words Hello and World (much like the italics do in this sentence). With this distinction, language becomes divided between the operational code and data. The computer here merely shuffles the words as so many strings of data, unconcerned about the contents. It does not interpret but only uses those strings. However, those words in quotation marks are significant to us, the humans who read the code. Hello and World have significance, just as the function name PRINT has a significance that goes far beyond its instructions to the computer and gestures toward a material culture of ink and writing
当然，计算机并不理解它说的是什么。从字面上看，计算机甚至无法解释这段代码。当函数被调用时，计算机将打印（输出）两个原子（在 LISP 中称为符号单元）的列表 Hello 和 World。单引号告诉计算机不要解释 Hello 和 World 这两个单词（就像这个句子中的斜体一样）。有了这种区别，语言就被划分为操作码和数据。在这里，计算机只是把单词当作许多数据字符串来处理，并不关心其内容。它不会解释，只会使用这些字符串。然而，对于我们这些阅读代码的人类来说，这些带引号的单词却意义重大。Hello 和 World 具有重要意义，正如函数名 PRINT 所具有的意义，远远超出了它对计算机的指示，也是对墨水和书写的物质文化的一种姿态
surfaces. More importantly, because the word PRINT, that special construct, could have been any set of characters in the programming language, the choice of the language designers in choosing PRINT reveals a central notion: code exists not for machines but for humans who need to communicate with the machine and with other humans. 

Nonetheless, it is as if to this point in the study of computer programming, all of computer code lies before us with single quotation marks preceding its lines. While we examine programming architecture and admire modularity and efficiency, the study of computer code does not currently emphasize interpretation, the search for and production of meaning. That is the realm of the humanities, the liberal arts, not computer science. Even when aesthetics intervenes, it comes in the form of calls for stylistic clarity for more efficient modification and development, though the subjective notions of “beauty” and “elegance” in code offer an opportunity for future conversations across the disciplines. However, there is so much more to be interpreted. Beyond the aesthetics of the code, there are questions of discourse (connotations, implications, resonance), social and material history, and ideology, just to name a few of the realms of inquiry that interpretation attempts to answer. By contrast, this emphasis on functionality neglects the meaning that code bears for its human audiences. For code, especially mid- to high-level languages, exists not solely for computers, which could operate on machine language (essentially, representations of electronic signals) or electronic signals alone, but for programmers as well. Therefore, the computer may be one recipient of the code, but there is also the programmer, other programmers, managers, and at times even users who have access to its text. In fact, the audiences for code have expanded as judges and lawyers, politicians and pundits, and even poets bring code into their discourse.
尽管如此，在研究计算机编程的过程中，似乎所有的计算机代码都是以单引号的形式出现在我们面前。虽然我们研究编程架构，钦佩模块化和效率，但计算机代码研究目前并不强调解释、意义的探寻和生成。这是人文学科和文科的范畴，而不是计算机科学。即使美学介入，也是以要求风格清晰以提高修改和开发效率的形式出现，尽管代码中 "美 "和 "优雅 "的主观概念为未来跨学科对话提供了机会。然而，还有很多东西需要解读。除了代码的美学之外，还有话语（内涵、寓意、共鸣）、社会和物质历史以及意识形态等问题，这只是解释学试图回答的几个探究领域。相比之下，对功能性的强调忽略了代码对人类受众的意义。因为代码，尤其是中高级语言，并不只是为计算机而存在，计算机可以通过机器语言（本质上是电子信号的表征）或电子信号进行操作，但也为程序员而存在。因此，计算机可能是代码的一个接收者，但还有程序员、其他程序员、管理者，有时甚至还有用户，他们都有机会接触到代码文本。事实上，随着法官和律师、政治家和学者，甚至诗人将代码引入他们的话语，代码的受众也在不断扩大。

Thus, to critique code merely for its functionality or aesthetics is to approach code with only a small portion of our analytic tools. In Life on the Screen, Sherry Turkle describes the Julia effect by which interactors ascribe intentionality and sentience to the computer that might display “Hello, World” (Turkle 1997, 101). This is to project humanity onto the computer, but is it possible that with regard to coding we do just the opposite and strip the code of its human significance, imagining that it is a sign system within which the extensive analyses of semiotic systems and signification, connotations that lead to denotations, do not apply? Is “Hello, World,” a rite of passage into many computer languages, the beginning of a literacy constrained by restricted interpretation? What would happen if we began to interpret the meaning of the code?
因此，仅仅从代码的功能性或美学角度来批判代码，只是我们分析工具的一小部分。在《屏幕上的生活》一书中，Sherry Turkle 描述了朱莉娅效应，通过这种效应，交互者将意向性和知觉赋予了可能显示 "你好，世界 "的计算机（Turkle 1997, 101）。这是将人性投射到计算机上，但在编码方面，我们是否有可能恰恰相反，剥离编码的人性意义，想象它是一个符号系统，在这个符号系统中，符号学系统和符号化的广泛分析、导致指称的内涵并不适用？你好，世界 "是许多计算机语言的入门仪式，它是否是受限于解释的读写能力的开端？如果我们开始解释代码的含义，会发生什么？

Consider again the example of the LISP “Hello, World.” I have already discussed the relationship of the programming language to the code, but that is just the beginning.
再来看看 LISP "你好，世界 "的例子。我已经讨论过编程语言与代码之间的关系，但这仅仅是个开始。

As it turns out, programmers learning to program in LISP tend to begin with code to produce the Fibonacci sequence rather than Hello, World. ${}^1$${}^1$^(1){ }^{1} Printing or displaying “Hello, World” does not always directly provide an introduction to the affordances of a language. Consider Ralph Westfall’s (2001) alternative “Hello, World” model that stresses the strict typing and object-oriented features of Java, an approach that in turn draws other alternatives. In fact, the debate over the use of “Hello, World” as an introductory exercise offers a glimpse into the ways that the how and the why of even simple programs can become the object of discourse and analysis in the social life of source code.
事实证明，学习 LISP 编程的程序员往往从生成斐波那契数列的代码开始，而不是从 "你好，世界 "开始。 打印或显示 "Hello, World "并不总能直接介绍一种语言的功能。拉尔夫-韦斯特法尔（Ralph Westfall，2001 年）提出了另一种 "Hello, World "模式，强调 Java 的严格类型和面向对象特性，这种方法反过来又吸引了其他替代方法。事实上，关于使用 "Hello, World "作为入门练习的争论让我们看到，即使是简单的程序，其 "如何 "和 "为何 "也能成为源代码社会生活中讨论和分析的对象。${}^2$${}^2$^(2){ }^{2}
事实证明，学习 LISP 编程的程序员往往从生成斐波那契数列的代码开始，而不是从 "Hello, World "开始。 ${}^1$${}^1$^(1){ }^{1} 打印或显示 "Hello, World "并不总是直接介绍一种语言的功能。Ralph Westfall（2001 年）提出了另一种 "Hello, World "模型，强调 Java 的严格类型和面向对象特性，这种方法反过来又吸引了其他替代方法。事实上，关于使用 "Hello, World "作为入门练习的争论，可以让我们窥见即使是简单的程序，其 "如何 "和 "为何 "也可以成为源代码社会生活中的讨论和分析对象。 ${}^2$${}^2$^(2){ }^{2}

As a new media scholar trained in literary theory, I would like to propose that we no longer speak of the code as a text in metaphorical terms, but that we begin to analyze and explicate code as a text, as a sign system with its own rhetoric, as semiotic communication that possesses significance in excess of its functional utility. Computer scientists can theorize on the most useful approaches to code, whereas humanities scholars can help by conjecturing on the meaning of code to all those who encounter it—both directly by reading it and indirectly by encountering the effects of the programs it creates. In effect, I am proposing that we can read and explicate code the way we might explicate a work of literature or other texts in a new field of inquiry that I call critical code studies (CCS).
作为一名接受过文学理论培训的新媒体学者，我想建议我们不再以隐喻的方式将代码视为文本，而是开始将代码作为文本、作为具有自身修辞的符号系统、作为具有超出其功能用途的意义的符号交流来分析和阐释。计算机科学家可以就最有用的代码方法提出理论，而人文学者则可以通过猜想代码对所有接触它的人的意义来提供帮助--直接通过阅读它，间接通过接触它所创建的程序的效果。实际上，我提议，我们可以像阐释文学作品或其他文本那样来阅读和阐释代码，这是我称之为批判性代码研究（CCS）的一个新的研究领域。

Critical code studies is an approach to code studies that applies critical hermeneutics to the interpretation of computer code, program architecture, and documentation within a sociohistorical context. CCS holds that the lines of code of a program are not value-neutral and can be analyzed using the theoretical approaches applied to other semiotic systems, in addition to particular interpretive methods developed specifically for the discussions of programs. Critical code studies follows the work of other critical studies, such as critical legal studies (Fitzpatrick and Hunt 1987; Tushnet 1991) and critical race studies (Delgado and Stefancic 2001; West 1995), in that it applies critical theory to a functional document (legal document or computer program) to explicate meaning in excess of its functionality and claims that this meaning warrants analysis on more than an aesthetic of efficiency. Meaning grows out of the functioning of the code but is not limited to the literal processes the code enacts. Through CCS, practitioners may critique the larger human and computer systems, from the level of the computer to the level of the society in which these code objects circulate and exert influence.
批判代码研究是一种代码研究方法，它将批判诠释学应用于在社会历史背景下对计算机代码、程序架构和文档的诠释。批判代码研究认为，程序的代码行并非价值中立，除了可以使用专门为讨论程序而开发的特殊解释方法外，还可以使用适用于其他符号系统的理论方法进行分析。批判性代码研究沿袭了其他批判性研究的工作，如批判性法律研究（Fitzpatrick and Hunt 1987; Tushnet 1991）和批判性种族研究（Delgado and Stefancic 2001; West 1995），它将批判性理论应用于功能性文件（法律文件或计算机程序），以阐释其功能之外的意义，并声称这种意义值得分析，而不仅仅是效率美学。意义源于代码的功能，但并不局限于代码所执行的字面流程。通过综合传播战略，实践者可以对更大的人类和计算机系统进行批判，从计算机层面到这些代码对象流通和施加影响的社会层面。

Rather than creating a language separate from the work of programmers, critical code studies will build on preexisting terminology and analysis used within the programming community. Much of the current examination of code seems to revolve
批判性代码研究不是创造一种独立于程序员工作之外的语言，而是建立在程序设计界使用的已有术语和分析基础之上。目前对代码的大部分研究似乎都围绕着
around efficiency of code, reusability, and modularity. This new critical approach will stress meaning, implication, and connotation, though not in terms of a self-contained system of meaning but with respect to the broader social contexts. Whereas a computer scientist might argue for or against various pragmatic approaches, scholars of CCS will interrogate the contexts and implications of a programmer’s choices. Whereas a computer scientist or programmer will focus primarily on how code functions or how it makes use of limited resources, critical code studies analyzes the extrafunctional significance of the code. Extra here means not outside of or in addition to but instead growing out of. The meaning of code is ambiguous because it is social, even while it is unambiguous because it is technological. The programmers’ expertise derives not solely from scientific knowledge but also from experience in the culture of programming.
批判性代码研究不是创造一种独立于程序员工作之外的语言，而是建立在程序设计界使用的已有术语和分析基础之上。目前对代码的大部分研究似乎都围绕着 围绕代码的效率、可重用性和模块化。这种新的批判性方法将强调意义、寓意和内涵，但不是从自成一体的意义系统的角度，而是从更广泛的社会背景的角度。计算机科学家可能会支持或反对各种实用方法，而计算机辅助学习的学者则会探究程序员所做选择的背景和含义。计算机科学家或程序员主要关注代码的功能或如何利用有限的资源，而批判性代码研究则分析代码的功能外意义。这里的 "额外 "指的不是代码之外或代码之外，而是代码之外。代码的意义是模糊的，因为它是社会性的，即使它是明确的，因为它是技术性的。程序员的专业知识不仅来自科学知识，也来自编程文化的经验。

Although some in the area of CCS may have an in-depth knowledge of programming, many analyses will benefit from the collaboration of critical theorists and programmers. Just as developing new media technologies requires the collaboration of artists and programmers, the scholarship will require the artful combination of knowledge of programming languages and programming methods and knowledge of interpretive theories and approaches. These analytic projects will require programmers to help open up the contents and workings of programs, acting as theorists along with other scholars as they reflect on the relationships of the code itself, the coding architecture, the functioning of the code, and specific programming choices, or expressions, with that which the code acts upon, outputs, processes, and represents.
尽管中央案例研究领域的一些人可能对编程有深入的了解，但许多分析将受益于批判理论家和编程人员的合作。正如开发新媒体技术需要艺术家和程序员的合作一样，学术研究也需要将编程语言和编程方法的知识与解释理论和方法的知识巧妙地结合起来。这些分析项目需要程序员帮助打开程序的内容和工作原理，与其他学者一起充当理论家，反思代码本身、编码架构、代码的功能、具体的编程选择或表达方式与代码所作用、输出、处理和代表的事物之间的关系。

Like literary analysis, CCS is an interpretive process rather than an instrumentally proscriptive or solely descriptive process. Other branches (lines of flight) of code studies may be concerned with pragmatics, but CCS focuses on meaning, read from the often collaborative and certainly iterative performance that is coding. Specific coding ideologies, such as open-source programming, also will be important, though CCS holds that language, as Gunther Kress and Robert Hodge (1979) have asserted, is already ideology. If “software is ideology,” as Wendy Hui Kyong Chun $(1999,207)$$(1999,207)$(1999,207)(1999,207) has announced, then we might also say computer code is also ideology, but an ideology that is doubly hidden by our illiteracy and by the very screens on which its output delights and distracts (ibid., 207). Whereas open source embodies a particular ideology that makes code accessible for analysis, CCS will analyze more than open-source programs, though access may be more limited. CCS will look broadly at choices in paradigms (such as object-oriented approaches) and closely at specific lines of code, their constraints, and their effects. Only through close attention to the specific details of the code will CCS be able to articulate what we might call the connotation of the code. 

Critical code studies draws upon the work of other scholars who have begun to interpret code, particularly Matthew Fuller’s Software Studies: A Lexicon (2008). Fuller’s collection, discussed in more detail ahead, offers a lexicon for the interpretation of software and its role in society. If Software Studies offers “a handbook of supplements to some of the key standard objects of computer science, programming and software culture” (2), critical code studies names a set of approaches, or an interpretive attitude, to code. Indeed, Fuller’s sense of software relates well to perspectives of CCS as he argues that “software can be seen as an object of study and an area of practice for kinds of thinking and areas of work that have not historically ‘owned’ software, or indeed often had much of use to say about it” (2). Software Studies opens the door for a formalized practice of (and quite a few tools for engaging in) critical code studies.
代码批判研究借鉴了其他学者的研究成果，这些学者已经开始对代码进行解释，特别是马修-富勒（Matthew Fuller）的《软件研究》（Software Studies）：词典》（2008 年）。Fuller 的文集为解读软件及其在社会中的作用提供了一本词典，下文将对此进行更详细的讨论。如果说软件研究提供了 "计算机科学、编程和软件文化的一些关键标准对象的补充手册"（2），那么批判性代码研究则命名了一套对代码的方法或解释态度。事实上，Fuller 对软件的理解与 CCS 的观点不谋而合，因为他认为 "软件可以被视为一种研究对象和实践领域，适用于那些历史上并不'拥有'软件的思维方式和工作领域，或者实际上往往对软件没有什么用处的思维方式和工作领域"(2)。软件研究为批判性代码研究的正规化实践（以及参与批判性代码研究的大量工具）打开了大门。

The mention of literature can be misleading here: I do not want to limit critical code studies to the study of code written as literature (as in Perl poetry), although this interpretation is certainly related. The focus of CCS is not on making code that has aesthetic value and additional meaning but on a view of code as already having meaning beyond its functionality because it is a form of symbolic expression and interaction. Nonetheless, analyses of Perl poetry, and codework in general, perform CCS and model methods for interpreting specific lines of code that can be applied to other kinds of source code.
这里提到文学可能会引起误解：我并不想将批判性代码研究局限于将代码写成文学作品（如 Perl 诗歌）的研究，尽管这种解释肯定是相关的。批判性代码研究的重点不在于编写具有审美价值和附加意义的代码，而在于认为代码已经具有超越其功能的意义，因为它是一种符号表达和交互形式。尽管如此，对 Perl 诗歌和一般代码工作的分析还是执行了 CCS，并建立了解释特定代码行的方法模型，这些方法可以应用于其他类型的源代码。

I also do not want to confuse CCS with literate programming, as outlined by Donald Knuth, author of The Art of Computer Programming (1973). In “Literate Programming” (1984), Knuth wrote, “Instead of imagining that our main task is to instruct a computer what to do, let us concentrate rather on explaining to human beings what we want a computer to do.” Knuth continues, “The practitioner of literate programming can be regarded as an essayist, whose main concern is with exposition and excellence of style” (97). By identifying code as a means of communicating not just with machines but also with other humans, Knuth contextualizes code as a mode of discourse, emphasizing the roles of clarity and style in its legibility, in its ability to communicate its purpose. However, the goal of critical code studies is not to aid programmers to write more readable code, though that may be an indirect effect, but instead to develop rich methods of reading that code. Drawing upon Knuth’s work, we can add style and clarity to the many aspects of code we analyze, but we must not end there.
我也不想将CCS与《计算机编程的艺术》（The Art of Computer Programming，1973）的作者唐纳德-克努特（Donald Knuth）所概述的 "有文化的编程"（literate programming）相混淆。在《识字编程》（1984 年）一书中，Knuth 写道："与其想象我们的主要任务是指导计算机做什么，不如让我们集中精力向人类解释我们希望计算机做什么。Knuth 接着说："有文化的编程实践者可以被视为散文家，他们主要关注的是阐述和卓越的风格"（97）。通过确定代码不仅是与机器交流的手段，也是与其他人交流的手段，Knuth 将代码语境化为一种话语模式，强调了清晰度和风格在其可读性中的作用，在其传达目的的能力中的作用。然而，批判性代码研究的目标并不是帮助程序员写出更可读的代码，尽管这可能是一个间接的效果，而是开发出阅读代码的丰富方法。借鉴 Knuth 的工作，我们可以为我们分析的代码的许多方面增加风格和清晰度，但我们绝不能就此结束。

Fundamental to CCS is the assumption that code is a social, semiotic system employing grammar and rhetoric. As Rita Raley (2006) argues, “Code may in a general sense be opaque and legible only to specialists, much like a cave painting’s sign system, but it has been inscribed, programmed, written. It is conditioned and concretely historical.” Adrian MacKenzie $(2003,19)$$(2003,19)$(2003,19)(2003,19) writes, “Code is written and run within situated practices,
密码学的基本假设是，密码是一种运用语法和修辞的社会符号系统。正如丽塔-雷利（Rita Raley，2006 年）所言，"从一般意义上讲，代码可能是不透明的，只有专家才能读懂，就像洞穴壁画的符号系统一样，但它已经被刻写、编程和书写。它是有条件的，是具体的历史"。Adrian MacKenzie $(2003,19)$$(2003,19)$(2003,19)(2003,19) 写道："代码是在情景实践中书写和运行的、
with reference to particular domains, and within particular orderings and disorderings of collective life. Its forms and abstractions are attached to lives.” It is in the way this sign system circulates within actor-networks of computers and machines that it develops connotations worthy of interpretation. 

In his entry in Software Studies, “Code (or, How You Can Write Something Differently),” Friedrich Kittler (2008) warns against diluting, and thereby mystifying and universalizing, the term code. (Kittler’s own code is the subject of chapter 6.) Kittler warns, “Codes-by name and by matter-are what determine us today, and what we must articulate if only to avoid disappearing below them completely. … The notion of code is as over-used as it is questionable” (40-45). Resistant to loose, associative interpretation, Kittler traces the derivation of the word back to codex and farther to codicilla, “the small tablets of stripped wood coated with wax in which letters could be inscribed.” In its later form, codex, the word signifies “simply the name of the bound book of law” (41). Code thus becomes the means and medium of long-distance control. Kittler follows the term from classical empires to nation-states to the moment when it becomes synonymous with cipher (42).
弗里德里希-基特勒（Friedrich Kittler，2008 年）在《软件研究》中的一篇文章《代码（或，如何写出与众不同的东西）》中警告说，不要淡化代码一词，从而将其神秘化和普遍化（基特勒自己的代码是第 6 章的主题）。(基特勒自己的代码是第 6 章的主题。）基特勒警告说："代码的名称和内容决定了今天的我们，我们必须阐明代码，以免完全消失在代码之下。......"（40-45）"代码 "这一概念被过度使用，也值得商榷。基特勒不接受松散的、联想式的解释，他将该词的起源追溯到codex，更远的则追溯到codicilla，"一种用木头制成的小片，上面涂有蜡，可以刻上字母"。在后来的codex形式中，该词 "仅仅是装订成册的法律书籍的名称"（41）。法典因此成为远距离控制的手段和媒介。Kittler 将这一术语从古典帝国沿用到民族国家，直至它成为密码的同义词（42）。

But interpreting code critically is not deciphering. Indeed, the very notion of “interpretation” can present an obstacle on the bridge between computer science and the humanities. A more mathematical mind might prefer the use of isomorphisms to this inexact relationship. In Douglas Hofstadter’s Gödel, Escher, Bach: An Eternal Braid (1979), he presents “interpretation” as meaningful isomorphisms, relationships drawn between one system and another. By Hofstadter’s formulation, an isomorphism, or interpretation, is meaningful only when the truths in one system produce truths in another system. To create an isomorphism, the two systems have to be completely interchangeable, such that each sign in one system can be equated to a sign in another system, essentially deciphering or decoding (51). This form of interpretation looks much more like transliterating or even compiling from a high-level language to a lowlevel one than it does interpretation in the humanities sense. By contrast, interpretation in a humanities context is less about mapping a one-to-one correspondence and more about identifying connections and resonances between signs and referents, as well as identifying disconnections and slippages along with the forces that shape or distort meaning.
但批判性地解读代码并不是破译。事实上，"解读 "这一概念本身就可能成为计算机科学与人文学科之间的障碍。相比这种不精确的关系，数学思维可能更倾向于使用同构。在道格拉斯-霍夫斯塔特（Douglas Hofstadter）的《哥德尔、埃舍尔、巴赫：永恒的辫子》（Gödel, Escher, Bach: An Eternal Braid，1979 年）一书中，他将 "解释 "表述为有意义的同构，即一个系统与另一个系统之间的关系。根据霍夫斯塔德的表述，只有当一个系统中的真理产生另一个系统中的真理时，同构或解释才是有意义的。要建立同构关系，两个系统必须完全可以互换，这样一个系统中的每个符号都可以等同于另一个系统中的符号，本质上就是破译或解码（51）。这种形式的阐释更像是从高级语言到低级语言的音译甚至编译，而不是人文意义上的阐释。相比之下，人文学科语境中的阐释更少涉及一一对应的映射，而更多涉及识别符号和所指之间的联系和共鸣，以及识别断开和滑动以及塑造或扭曲意义的力量。

For example, PRINT from our “Hello, World” program is a token that causes that data to display on the screen. As we discuss in 10 PRINT, the command PRINT has its origins as a command to put ink on paper. An isomorphism can be made between the command PRINT as a command to display text on the screen and the teletype putting a word on paper, or between PRINT and a similar token in another programming
例如，"Hello, World "程序中的 PRINT 就是一个令牌，它能使数据显示在屏幕上。正如我们在 10 PRINT 中讨论的那样，PRINT 命令起源于将墨水涂在纸上的命令。PRINT 命令作为在屏幕上显示文字的命令，与电传打字机将文字写在纸上的命令，或者 PRINT 命令与其他编程语言中的类似标记之间，存在同构关系。
language, such as WriteLine in C#. However, the command PRINT can be interpreted in many ways that are more associative. Print evokes a system of inscription, the history of print, the way the computer screen remediates text printed on paper. ${}^3$${}^3$^(3){ }^{3} Although the isomorphism offers a parallel, interpretation can indicate more extensive realms of meaning.
例如，"Hello, World "程序中的 PRINT 就是一个令牌，它能使数据显示在屏幕上。正如我们在 10 PRINT 中讨论的那样，PRINT 命令起源于将墨水涂在纸上的命令。PRINT 命令作为在屏幕上显示文字的命令，与电传打字机将文字写在纸上的命令，或者 PRINT 命令与其他编程语言中的类似标记之间，存在同构关系。 语言，如 C# 中的 WriteLine。然而，"打印"（PRINT）命令可以有许多更具联想性的解释。打印 "让人联想到刻印系统、印刷历史、计算机屏幕重塑纸上印刷文本的方式。 虽然同构提供了一个并列关系，但解释可以表明更广泛的意义领域。

Interpretation is not limited to compiling or porting. Interpretation in the humanities sense is more akin to porting a program from one language to another, where a programmer has to make conscious choices about how to represent one system in another and the porting requires a subjective assessment of what is the essence of the program. Yet interpretation in the humanities goes beyond compiling and porting because it asks, “If $x$$x$xx represents $y$$y$yy, what is being communicated about both systems?” It asks, “How does one realm of meaning inform or affect another?” In other words, interpretation in the humanities sense is neither deciphering nor translating, but instead uses those techniques (and other hermeneutics) to get at meaning beyond the isomorphic systems. Interpretation then is not merely decoding but the production of another kind of knowledge: insight. Those insights may appear quite arbitrary when someone is approaching the code with a systematic point of view, when one is attending the logic of the systems rather than potentially challenging it. 

Kittler offers this more robust model of interpretation as he explores the origins and context of computer code. In this historical narrative, codes prove to be central to subjugation as the military motto changes from “Command, Control, Communication, Intelligence” to “Command, Control, Communication, Computers” (C^4). He writes, “Today, technology puts the code into practice of realities, that is to say: encodes the world” $(2008,45)$$(2008,45)$(2008,45)(2008,45). Central to control is the ability to make “code” a ubiquitous, universal operator. Moreover, he adds, “But perhaps code means nothing more than codex did at one time: the law of precisely that empire which holds us in subjection and forbids us even to articulate this sentence. At all events, the major research institutions which stand to profit most from such announcements proclaim with triumphant certainty that there is nothing in the universe, from the virus to the Big Bang, which is not code” (45).
基特勒在探讨计算机代码的起源和背景时，提供了这种更为有力的解释模式。在这一历史叙事中，随着军事格言从 "指挥、控制、通信、情报 "变为 "指挥、控制、通信、计算机"（C^4），代码被证明是征服的核心。他写道："今天，技术将代码付诸实践，也就是说：对世界进行编码" $(2008,45)$$(2008,45)$(2008,45)(2008,45) 。控制的核心是使 "代码 "成为无处不在的通用运算符的能力。此外，他还补充道："不过，也许代码的意义并不亚于曾经的法典：正是这个帝国的法律压制着我们，甚至禁止我们说出这句话。无论如何，从这些声明中获利最多的主要研究机构都会非常肯定地宣称，从病毒到宇宙大爆炸，宇宙中没有任何东西不是代码"（45）。

Here, the military-industrial complex employs the codes for control, and by making “code” the essence of all life, a few elite, literate researchers establish themselves as the only mediators. To regain command and control of the term, Kittler sets out to restrain it within a technical definition. He announces, “Only alphabets in the literal sense of modern mathematics should be known as codes, namely one-to-one, finite sequences of symbols, kept as short as possible but gifted, thanks to a grammar, with the incredible ability to infinitely reproduce themselves” (2008, 45). Kittler is circumscribing
在这里，军事工业综合体利用代码进行控制，通过将 "代码 "作为所有生命的本质，少数有文化的精英研究者将自己确立为唯一的调解人。为了重新掌握和控制这个术语，基特勒开始将其限制在一个技术定义中。他宣布："只有现代数学字面意义上的字母表才应被称为代码，即一对一、有限的符号序列，尽可能保持简短，但得益于语法，具有无限复制自身的惊人能力"（2008, 45）。基特勒将其定义为
the notion of code here, but to what end? Critical code studies may observe some of Kittler’s suggested restraint, keeping code from becoming a controlling, transcendental imaginary. However, these one-to-one unambiguous systems develop ambiguous meanings the moment they enter the social sphere-in other words, the moment they are uttered or even the moment they are thought, come into existence in the context of human consciousness, in meaning-making machines. In examining code in context, CCS will look toward and beyond characters to interpret gestures, performances, and possibilities.
基特勒在这里提出了 "代码 "的概念，但目的何在？批判性代码研究可能会遵守基特勒建议的一些克制，使代码不成为一种控制性的、超验的想象。然而，这些一一对应的明确系统在进入社会领域的那一刻--换句话说，在它们被说出的那一刻，甚至在它们被思考的那一刻，在人类意识的语境中，在意义制造机中，就产生了模糊的意义。在研究语境中的代码时，CCS 将着眼于字符，并超越字符来解读手势、表演和可能性。

Everything. The code, the documentation, the comments, the structures, the compiled versions-all will be open to interpretation. Greater understanding of (and access to) these elements will help critics build complex readings. In his essay “The Code is Not the Text (Unless It Is the Text),” John Cayley (2002) argues that much of the code that was being analyzed in works of electronic art was not code per say, but gestures toward code. At the time, Cayley argued that code was not really the text unless it was executable code. ${}^4$${}^4$^(4){ }^{4} In “A Box, Darkly,” Michael Mateas and Nick Montfort (2005) counter Cayley’s claim of the necessity for executability by acknowledging that code can be written for programs that will never be executed. Within CCS, if it is part of the program or a paratext (understood broadly), it contributes to meaning. In the case of codework, if the artifact is code-like, it can shape how we read code. I would also include interpretations of markup languages and scripts as extensions of code. Within the code, critics will examine the actual symbols but also, more broadly, procedures, structures, and gestures. There will be paradigmatic choices made in the construction of the program, methods chosen over others, and connotations.
一切。代码、文档、注释、结构、编译版本--所有这些都可以进行解读。更好地理解（和获取）这些元素将有助于评论家进行复杂的解读。约翰-凯利（John Cayley，2002 年）在他的文章《代码不是文本（除非它就是文本）》中指出，电子艺术作品中被分析的大部分代码本身并不是代码，而是对代码的姿态。当时，Cayley 认为代码并不是真正的文本，除非它是可执行代码。 ${}^4$${}^4$^(4){ }^{4} 在《A Box, Darkly》中，迈克尔-马特斯和尼克-蒙特福特（2005）反驳了凯利关于可执行性必要性的说法，承认可以为永远不会被执行的程序编写代码。在CCS中，如果代码是程序的一部分或副文本（广义理解），那么它就对意义有所贡献。就代码工作而言，如果人工制品类似于代码，那么它就会影响我们阅读代码的方式。我还想把对标记语言和脚本的解读也作为代码的延伸。在代码中，评论家们将研究实际符号，但也会更广泛地研究程序、结构和手势。在构建程序的过程中，会有范式选择、方法选择和内涵选择。

In addition to symbols and characters in the program files themselves, these paratextual features also will be important for informed readers. The history of the program, the author, the programming language, the genre, the funding source for the research and development (be it military, industrial, entertainment, or other), all shape meaning, although any one reading might emphasize just a few of these aspects. The goal need not be code analysis for code’s sake, but analyzing code to better understand programs and the networks of other programs and humans they interact with, organize, represent, manipulate, transform, and otherwise engage. Reading code functions as an entry point to reading culture.
除了程序文件本身的符号和字符外，这些副文本特征对知情读者也很重要。程序的历史、作者、编程语言、流派、研发的资金来源（无论是军事、工业、娱乐还是其他方面），所有这些都会塑造意义，尽管任何一次阅读都可能只强调其中的几个方面。我们的目标不一定是为了分析代码而分析代码，而是通过分析代码来更好地理解程序以及与之交互、组织、表示、操作、转换和以其他方式参与的其他程序和人类网络。阅读代码是阅读文化的切入点。

There are multiple audiences for code. At first glance, the only audience appears to be the machine itself, but, as mentioned, humans are the ones who require symbolic
代码有多种受众。乍一看，唯一的受众似乎是机器本身，但如前所述，人类才是需要符号代码的人。
representation. First, assuming it is created by a human and not other software, the programmer reads the code even while compositing it. Second, other programmers may read the code. Third, nonprogrammers, such as project managers or audiences of interdisciplinary conferences, may read the code. The code also may end up in the hands of hackers. Even the machine on which the computer runs may prove to be multiple audiences, as parts of the code are passed to other processes and other parts of the machine. Furthermore, there already are many sites of conversation about code. Jeremy Douglass (2011) notes several of these in his call to find code discussions “in the wild,” noting discussions in business meetings, in the courts, and even in the mainstream news.
代表性。首先，假设代码是由人而不是其他软件创建的，那么程序员即使在合成代码时也会读取代码。其次，其他程序员也可能阅读代码。第三，非程序员，如项目经理或跨学科会议的听众，可能会阅读代码。代码也可能最终落入黑客之手。甚至计算机运行的机器也可能成为多重受众，因为代码的一部分会传递给其他进程和机器的其他部分。此外，现在已经有很多关于代码的交流场所。杰里米-道格拉斯（Jeremy Douglass）（2011 年）在呼吁 "在野外 "寻找代码讨论时提到了其中的几个，他还提到了商业会议、法庭甚至主流新闻中的讨论。

To return to the example that started this chapter, we might note that the LISP “Hello, World” program did not appear out of nowhere. It was written by Mark Singletary, a programming architect, variously employed by NASA and software firms. His apparent specialty is usability, or the development of easily read human-computer interfaces, the facilitation of interaction between human and machine realms. The relationship between code and coder, the program that makes computers speak to a “world” and the programmer who works (for a government-funded, space-exploration, C^4 institution) to make computers speak more clearly, creates meaning. Moreover, Singletary submitted this “beginner” code to the Association for Computing Machinery (ACM) “Hello World” Project (Singletary 2005), a project that in its very being suggests additional audiences for practice code. What does it mean for ACM to collect samples of “first exposure to a new language” (Singletary 2005)? What does it mean when an exercise, a rite of passage, is anthologized?
回到本章开头的例子，我们可以注意到，LISP "Hello, World "程序并不是凭空出现的。它是由编程架构师马克-辛格莱特里（Mark Singletary）编写的，他曾受雇于美国国家航空航天局（NASA）和软件公司。他的专长显然是可用性，即开发易读的人机界面，促进人机交互。代码与编码员之间的关系，即让计算机与 "世界 "对话的程序与（为政府资助的太空探索 C^4 机构工作的）让计算机更清晰地对话的程序员之间的关系，创造了意义。此外，辛格莱特里还将这一 "初学者 "代码提交给了美国计算机协会（ACM）的 "Hello World "项目（辛格莱特里，2005 年）。ACM 收集 "初次接触新语言"（Singletary 2005）的样本意味着什么？当一种练习、一种仪式被选入文集时，它意味着什么？

Suddenly this practice code has a showcase. ${}^5$${}^5$^(5){ }^{5} Thus, the “world” the program greets has expanded to include other programmers at computers with internet access (qualifiers that constrain the world to an absurdly tiny portion of the Earth’s population). This particular code joins a conversation of comparative study rather than merely demonstrating incipient ability in a language. Moreover, it is hardly the only way to write a “Hello, World” program in LISP. So, like all semiotic utterances, it offers a glimpse into what Saussure calls the paradigm of possible formulations (Saussure and Riedlinger 1983, 121-124). Certainly, this program is not just a piece of code processed by the computer. It is an artifact circulating in a broader exchange. Although I will not offer definitive readings of the material, sociohistorical factors of this code object, risking the unnecessary circumscription of CCS at its outset, I merely wish to demonstrate how all these contextualizing aspects potentially affect the way “Hello, World” means.
突然间，这个实践代码有了一个展示平台。 ${}^5$${}^5$^(5){ }^{5} 因此，该程序所迎接的 "世界 "已经扩大到包括其他可以上网的电脑程序员（限定词将世界限制为地球人口中荒谬的一小部分）。这个特殊的代码加入了比较研究的对话，而不仅仅是展示一种语言的萌芽能力。此外，用 LISP 编写 "Hello, World "程序的唯一方法也并非如此。因此，与所有符号学语篇一样，它提供了对索绪尔所说的可能表述范式的一瞥（索绪尔和里德林格，1983 年，121-124 页）。当然，这个程序不仅仅是计算机处理过的一段代码。它是在更广泛的交流中流通的人工制品。虽然我不会对这一代码对象的物质和社会历史因素进行明确的解读，冒着一开始就对计算机辅助语言进行不必要的限定的风险，但我只想证明所有这些语境化的方面是如何潜在地影响 "你好，世界 "的含义的。

Key to critical code studies will be programming literacy. Just as a student of literature might learn a foreign language or sign language or dance, a student of CCS
关键代码研究的关键是编程素养。正如学习文学的学生可能会学习外语、手语或舞蹈一样，学习 CCS 的学生也可能会
only will be able to access code by learning (and preferably mastering) the language. ${}^6$${}^6$^(6){ }^{6} Rita Raley (2002) has speculated about the possibility of computer languages counting for language requirements in undergraduate and graduate programs in the humanities. Alternatively, an interpreter could collaborate with someone who is literate in the language, building networks of literacy, coalitions of meaning-building. We might consider such fluency cyborg literacy. Computer scientists already write translations through their ports of programs. Perhaps computer scientists one day even will write exegetical guides. In textbooks on programming, no doubt they do.
只有通过学习（最好是掌握）这种语言，才能获取代码。 ${}^6$${}^6$^(6){ }^{6} 丽塔-雷利（Rita Raley）（2002 年）曾推测，计算机语言有可能成为人文学科本科和研究生课程的语言要求。另外，口译员还可以与精通该语言的人合作，建立识字网络和意义建构联盟。我们可以将这种流畅性视为机器人扫盲。计算机科学家已经通过他们的程序端口编写翻译。也许有一天，计算机科学家甚至会编写注释指南。毫无疑问，他们已经在编程教科书中这样做了。

Although it may seem that a literary critic can only interpret the natural language elements, critical code studies cannot narrow its scope to only the natural language or arbitrary features of the code. For example, a program that calculates automobile insurance rates might have a variable called victim. However, variable and method names are relatively easy targets for interpretation and themselves fall victim to the accusation that they are arbitrary elements of the code, comparatively meaningless to the functioning of the machine. Victim could just as easily be $f2s989$$f2s989$f2s 989f 2 s 989. On the one hand, the relationship between most signifiers and signifieds is, in semiotic terms, arbitrary, and yet is still quite meaningful. On the other hand, the names of built-in methods, the syntax and logic of a computer language, seem to have a more notable operational significance to the computer system. Therefore, a critical code studies that only speaks of variable names and never of language tokens and fundamentals would be relatively shallow. Former professional programmer and scholar of technoculture Evan Buswell (ebuswell, comment on Feinstein et al. 2011) has made this point eloquently. Imagining the consequences of such an approach, Buswell sees a future in which a group of programmers worry about making things work, while the code critics discuss variable and method names in some room off to the side.
虽然文学评论家似乎只能对自然语言元素进行解释，但批判性代码研究不能将其范围仅仅缩小到代码的自然语言或任意特征上。例如，一个计算汽车保险费率的程序可能有一个名为 victim 的变量。然而，变量名和方法名相对来说比较容易被解释，而且它们本身也容易被指责为代码中的任意元素，对机器的运行相对来说毫无意义。受害者也可以是 $f2s989$$f2s989$f2s 989f 2 s 989 。一方面，从符号学的角度来看，大多数符号和被符号之间的关系都是任意的，但却仍然非常有意义。另一方面，内置方法的名称、计算机语言的语法和逻辑，对于计算机系统似乎具有更显著的操作意义。因此，只谈变量名而不谈语言符号和基本原理的代码批判性研究是相对肤浅的。前职业程序员、技术文化学者埃文-布斯韦尔（Evan Buswell，对费恩斯坦等人 2011 年的评论）曾雄辩地指出了这一点。在想象这种方法的后果时，Buswell 认为在未来，一群程序员将为如何让程序运行而操心，而代码评论家则在一旁的房间里讨论变量和方法名称。

Critical code studies is not limited to any one type of programming schema, whether imperative, object-oriented, functional, or other. Nor should it be limited to programming languages that use textual symbols. CCS is built on semiotic analysis, so its methods can be applied to any representational system, be it text-based, visual, or even gestural. In fact, for CCS to be fully robust, its methods also should be applicable to direct programming through hardware-for example, in the building of microcircuits. Although some may argue that analysis may seem to encroach upon platform studies, policing those boundaries will only obscure the complex interrelations between software and hardware. In other words, CCS should not stop its analysis merely when it crosses out of some limited jurisdiction but must instead collaborate with the interrelated fields of study that are making rich understandings of contemporary technoculture possible.
批判性代码研究并不局限于任何一种编程模式，无论是命令式、面向对象、函数式还是其他。它也不应局限于使用文本符号的编程语言。CCS 建立在符号学分析的基础上，因此其方法可以应用于任何表征系统，无论是基于文本的、视觉的，甚至是手势的。事实上，要使 CCS 完全强大，其方法还应适用于通过硬件进行的直接编程--例如，微电路的构建。虽然有些人可能会说，这种分析似乎侵犯了平台研究，但对这些界限的限制只会掩盖软件和硬件之间复杂的相互关系。换句话说，CCS 不应该仅仅在其分析超出了某些有限的管辖范围时就停止分析，而是必须与相互关联的研究领域合作，因为这些研究领域正在使人们对当代技术文化的丰富理解成为可能。

Computer code is not some undiscovered continent. Nor is it some magical sign system. It is a realm of creativity and production that has been around for more than half a century. It would be a terrible mistake to enter discussions about code by offering to interpret it for the very programmers who have been slogging away in it for so long. To do so would be to commit the offense of techno-Orientalism. Numerous definitions have been offered for such an act, but they all trace back to Eduard Said’s term for the way scholars in the West create a sense of the inscrutable East, Asian culture and language, and then proceed to interpret it devoid of an understanding of the contexts or even of those who have already established a conversation of interpretation. It is the epitome of the hubris of cultural imperialism to offer to explain someone else’s culture to them. Critical code studies must therefore work in collaboration and in conversation with those who have already laid the groundwork for this analytical endeavor.
计算机代码并不是什么未被发现的大陆。也不是什么神奇的符号系统。它是一个已经存在了半个多世纪的创造和生产领域。在关于代码的讨论中，如果提出要为长期从事代码工作的程序员解释代码，那将是一个可怕的错误。这样做就犯了技术东方主义的错误。关于这种行为的定义不胜枚举，但都可以追溯到爱德华-赛义德（Eduard Said）的术语，即西方学者对高深莫测的东方、亚洲文化和语言产生一种感觉，然后在不了解背景甚至不了解那些已经建立了解释对话的人的情况下，对其进行解释。主动向别人解释别人的文化是文化帝国主义狂妄的缩影。因此，批判性代码研究必须与那些已经为这一分析工作奠定基础的人合作和对话。

At this point, someone might ask, Shouldn’t we be interpreting machine language? Perhaps. But that would not bring us closer to the truth of the code. That is not what we’re after. Such interpretations might find models in critiques of numerals, such as Brian Rotman’s Signifying Nothing (1993), which suggests that much can be made of nothingness. Equations have lives of their own, as texts such as David Bodanis’s $E=m{c}^2$$E=m{c}^2$E=mc^(2)E=m c^{2} (2000) demonstrate. Perhaps one of the most powerful texts that illustrates the move between modes of representation and systems of expression is Hofstadter’s Gödel, Escher, Bach (1979), which draws correspondences between natural languages, math, programming, music, and drawing. Where the line between mathematics and CCS is, I do not wish to declare. I would merely suggest that there are qualities of computer languages that give a program more footholds for interpretation.
说到这里，有人可能会问，我们不是应该对机器语言进行解释吗？也许吧。但这不会让我们更接近代码的真相。这不是我们所追求的。这样的诠释或许可以在对数字的批判中找到范本，比如布赖恩-罗特曼（Brian Rotman）的《虚无的意义》（Signifying Nothing，1993 年），该书认为虚无可以创造出很多东西。正如戴维-博达尼斯的 $E=m{c}^2$$E=m{c}^2$E=mc^(2)E=m c^{2} （2000 年）等著作所展示的那样，等式也有自己的生命。霍夫施塔特的《哥德尔、埃舍尔、巴赫》（Gödel, Escher, Bach）（1979 年）也许是最能说明表征模式与表达系统之间关系的文本之一，它在自然语言、数学、编程、音乐和绘画之间建立了对应关系。我不想宣布数学与计算机科学之间的界限在哪里。我只想说，计算机语言的某些特质为程序的解释提供了更多的立足点。

However, it is important not to think that reading assembly or machine language or binary code is reading a truer code. Wendy Chun has expressed concerns about the tendency to treat source code as something essential, as the heart of the program, even conflating it with the executable code that the source code is compiled into. Such a search risks engaging in what she calls a kind of “sourcery” (Chun 2011). The question is not whether it is better to read a higher- or lower-level language, but what someone wishes to explore. For example, Patrick LeMieux (2015) has read the assembly language of Cory Arcangel’s Super Mario Clouds to study the mechanisms of that work. To be sure, machine language code offers access to a level that is more directly tied to hardware. However, just as Chun’s critique helps remind us that source code is an intermediate
然而，重要的是不要认为阅读汇编语言、机器语言或二进制代码就是阅读更真实的代码。温迪-春（Wendy Chun）曾对将源代码视为程序核心的基本要素，甚至将其与源代码编译成的可执行代码混为一谈的倾向表示担忧。这样的搜索有可能陷入她所说的 "源代码"（Chun，2011 年）。问题不在于阅读高级语言好还是低级语言好，而在于人们希望探索什么。例如，帕特里克-勒米厄（Patrick LeMieux，2015）阅读了科里-阿坎格尔（Cory Arcangel）的《超级马里奥云》（Super Mario Clouds）的汇编语言，以研究该作品的机制。可以肯定的是，机器语言代码提供了与硬件更直接联系的层面。然而，正如 Chun 的批评有助于提醒我们，源代码是一个中间环节。
representation of machinic commands, her intervention also suggests that no level of the code need be privileged. I would add that meaning is produced when the code is interpreted by human readers. Therefore, though no one level of the code is more meaningful than any other, every level of the code and hardware is a potential source of meaning.
她的干预还表明，代码的任何层次都无需享有特权。我想补充的是，当代码被人类读者解读时，意义就产生了。因此，尽管没有哪一层代码比其他任何一层代码更有意义，但每一层代码和硬件都是潜在的意义来源。

Although critics do not need to dive down to some deeper level of code for more meaning, they must also be careful not to read the code as sufficient unto itself. Matthew Kirschenbaum (2011) has raised concerns on several occasions about the hazards of reading code separated from its context. He warns that to stop at the code is to lose sight of the many other systems with which code interacts and on which it operates. Instead, he argues a critic should explore the way the code interacts with other systems and hardware. High-level code is portable across multiple platforms, but it is no less situated. Although those situations may be too numerous to count, the software and hardware circumstances of the code are crucial to its interpretation.
尽管批评家不需要深入到代码的更深层次去探寻更多意义，但他们也必须小心谨慎，不要把代码理解为其本身就足够了。Matthew Kirschenbaum（2011 年）曾多次对脱离上下文阅读代码的危害表示担忧。他警告说，如果只停留在代码上，就会忽略与代码相互作用并在其上运行的许多其他系统。相反，他认为评论家应该探索代码与其他系统和硬件的交互方式。高级代码可以在多个平台上移植，但它的处境也不例外。虽然这些情况可能多得难以计数，但代码的软件和硬件环境对其解释至关重要。

With both these cautions in mind, we who are setting out to explore and develop critical code studies have developed a few practices. The first practice is the acknowledgement that code is an entry point to an investigation rather than an end in itself. Perhaps the clearest example of that method was the eponymous study of a one-line basic program: 10 PRINT CHR$ (205.5 + RND (1)); : GOTO 10 (Montfort et al. 2013). The ten-authored exploration used this simple yet influential program as the starting point for a discussion of the BASIC programming language, the Commodore 64 computer, procedural art, and even mazes. Although each token of the program (10, PRINT, CHR$, etc.) was analyzed, so too were concepts of randomness and regularity, hardware and specifications, and design principles that made the program possible. Material aspects were analyzed, such as the configuration of the Commodore 64’s monitor, but so too were social aspects, such as the zeitgeist of “home computing.” Rather than a beach ball bouncing in undirected free association, the program acted as the hub of a spoked wheel, with lines of inquiry running outward from yet always linked back to it. And apropos of such a recursive program, the process led back to its center, to that one line and its seemingly unending potential energy. Thus, even the analysis of a program one line long could not be discussed in isolation.
考虑到这两点，着手探索和发展批判性代码研究的我们形成了一些做法。第一种做法是承认代码是研究的切入点，而非目的本身。这种方法最明显的例子或许是对单行基本程序的同名研究：10 PRINT CHR$ (205.5 + RND (1)); : GOTO 10 (Montfort et al. 2013)。这篇由十位作者撰写的探讨文章以这个简单却极具影响力的程序为起点，讨论了 BASIC 编程语言、Commodore 64 计算机、程序艺术甚至迷宫。虽然对程序中的每一个标记（10、PRINT、CHR$ 等）都进行了分析，但随机性和规律性、硬件和规格以及使程序成为可能的设计原则等概念也都进行了分析。我们分析了物质方面的问题，如 Commodore 64 显示器的配置，也分析了社会方面的问题，如 "家庭计算 "的潮流。与其说程序是一个在无定向自由联想中弹跳的沙滩球，不如说它是一个辐条轮的枢纽，从它向外延伸的探究线总是与它联系在一起。与这样一个递归程序相称的是，这个过程又回到了它的中心，回到了那条线和它似乎无穷无尽的潜在能量。因此，即使是对一行之长的程序进行分析，也不能孤立地进行讨论。

Another development from this intervention has been the recognition of the need for tools to discuss code without having to strip it from its setting. Offering a solution to the challenges of contextualizing code, Kirschenbaum proposed reading code within its version control setting. We have begun experimenting with such a possibility in projects built on ANVC Scalar and a specific adaptation of it called ACLS Workbench. ${}^7$${}^7$^(7){ }^{7} In both contexts, the Scalar software platform allows users to import code as
这种干预的另一个进展是，人们认识到需要一些工具来讨论代码，而不必将代码从其环境中剥离出来。Kirschenbaum 提出了一种解决代码上下文化难题的方法，即在版本控制环境中阅读代码。我们已经开始在基于 ANVC Scalar 的项目中尝试这种可能性，并对其进行了特定的调整，称为 ACLS Workbench。 ${}^7$${}^7$^(7){ }^{7} 在这两种情况下，Scalar 软件平台都允许用户将代码导入为
text from source code repositories, maintaining its connection to its fuller context. For example, in my reading of the Transborder Immigrant Tool (chapter 2), I have used Scalar to import specific files from the repository of the code so that the files are still connected to their context in the much larger piece of software. Using this technique of importing situated files, critics can comment on code in situ rather than excerpting it and removing it from its development environment. This approach still involves an abstraction because the code is being read through a browser separated from the platform (or even an emulator of that platform) on which it is intended to run. Nonetheless, these examples mark merely the early efforts in the development of platforms for the scholarly analysis of code. The lesson is clear: every piece of source code is only ever partial.
从源代码库中导入文本，保持其与更完整上下文的联系。例如，在我对《跨境移民工具》（第 2 章）的解读中，我使用 Scalar 从代码库中导入特定文件，这样这些文件在更大的软件中仍然与其上下文相关联。利用这种导入情景文件的技术，评论者可以就地对代码进行评论，而不是摘录代码并将其从开发环境中移除。这种方法仍然涉及抽象问题，因为代码是通过浏览器读取的，与运行平台（甚至是该平台的模拟器）是分离的。尽管如此，这些例子只是开发学术性代码分析平台的早期努力。教训是显而易见的：每一段源代码都只是局部的。

Loss Pequeño Glazier’s (2006) article in Leonardo Electronic Almanac, “Code as Language,” argues that “if language is defined as written symbols organized into combinations and patterns to express and communicate thoughts and feelings-language that executes-then coding is language.” Glazier is establishing code as a creative, even literary, act, a kind of inscription or “thinking through thought.” In his essay, Glazier offers additional objects for CCS analysis, including the amount of processor speed a particular operation requires. His example points to the double nature of code as a record and a piece of a real-time process. More than utilitarian commands, code presents signs of “humor, innovation, irony, double meanings, and a concentration on the play of language. It is the making of marks with a sense of marksmanship.” Again, key to CCS is an understanding that the challenges of programming and encoding are not finding one correct command out of a codex of commands, but of choosing (and at times creating) a particular combination of lines to build a structure that resonates and operates aesthetically, functionally, and even conceptually with the other discourse of encoded objects, as well as mathematical and natural language discourse.
Loss Pequeño Glazier（2006 年）在《莱昂纳多电子年鉴》（Leonardo Electronic Almanac）上发表的文章《作为语言的代码》认为，"如果语言被定义为组织成组合和模式的书面符号，用来表达和交流思想和情感--执行的语言，那么编码就是语言"。格莱泽将代码定义为一种创造性行为，甚至是文学行为，一种铭文或 "通过思想进行思考"。在文章中，格莱泽还提供了更多的 CCS 分析对象，包括特定操作所需的处理器速度。他的例子指出了代码作为记录和实时过程的一部分的双重性质。代码不仅仅是功利性的命令，它还表现出 "幽默、创新、讽刺、双重含义以及对语言游戏的专注"。它是一种有标记感的标记"。同样，CCS 的关键在于理解编程和编码所面临的挑战并不是从众多命令中找到一个正确的命令，而是选择（有时是创造）一个特定的行的组合，以建立一个在美学上、功能上、甚至在概念上与编码对象的其他话语以及数学和自然语言话语产生共鸣和运作的结构。

If code is language, does that make programs poetry? In “The Aesthetics of Generative Code,” Geoff Cox, Alex McLean, and Adrian Ward (2000) compare code to poetry as they develop some techniques for interpreting it. In their words, “Evidently, code works like poetry in that it plays with structures of language itself, as well as our corresponding perceptions.” Like Cayley and others, they argue that code’s meaning is bound up with its execution. However, their reading is not limited to the performance of the code, as they also “stress more purposeful arrangements of code by the programmer.” For example, they note that even the visual presentation of code is designed for
如果代码是语言，那么程序就是诗歌吗？在《生成代码的美学》一书中，Geoff Cox、Alex McLean 和 Adrian Ward（2000 年）将代码与诗歌相提并论，并开发了一些解读代码的技术。用他们的话说，"显而易见，代码的作用就像诗歌一样，它玩弄语言本身的结构以及我们相应的感知"。与 Cayley 等人一样，他们也认为代码的意义与代码的执行息息相关。然而，他们的解读并不局限于代码的执行，因为他们还 "强调程序员对代码更有目的性的安排"。例如，他们指出，即使是代码的视觉呈现也是为以下目的而设计的
human readers because “the same code could be expressed in any shape or arrangement and would run the same output.” Nonetheless, in an exemplary move of CCS, they examine the play of language from a Perl poem in which the author uses “=” (“a string comparison operator”) instead of “eq” (“a numeric one”). Here through an act of close reading, they articulate the significance of a paradigmatic choice to the larger meaning of the piece. To further argue that code is a linguistic form for human audiences, they present their paper as a “conditional statement” of code (if, then), wherein an “if” is followed by their abstract as the {condition} and the essay body is marked as the {statement}. Although they make a strong case for a human poetics in the construction of code, to suggest that all code adheres to an aesthetics or works toward readability is to overstate the case. Nonetheless, code communicats through symbols and whitespace.
人类读者，因为 "同样的代码可以用任何形状或排列来表达，并运行同样的输出"。然而，在 CCS 的一个典范行动中，他们研究了一首 Perl 诗中的语言游戏，在这首诗中，作者使用了"="（"字符串比较运算符"）而不是 "eq"（"数字一"）。在这里，通过细读，他们阐明了范式选择对于作品更大意义的重要性。为了进一步论证代码是一种面向人类受众的语言形式，他们将论文表述为代码的 "条件陈述"（if, then），其中 "if "后面的摘要被标记为{条件}，而论文正文则被标记为{陈述}。虽然他们有力地证明了代码构造中的人类诗学，但认为所有代码都遵循美学或致力于可读性，未免言过其实。然而，代码通过符号和空白进行交流。

Excluding the few art objects written as poetry, most code is worlds away from literature, film, and visual art and more similar to legal code, inasmuch as the text is functional and primarily designed to do rather than to be, to perform rather than reflect. Unlike legal code, however, computer code typically is presumed to be unseen by human eyes. Nonetheless, except in cases in which the computer generates code that its programmers and users never see, computer code is often seen by other programmers who must rework it. Further, even if the code is only seen by its programmer, like a diary locked away or letters never sent, it is still a semiotic expression. (Of course, computer-generated code presents the author as cyborg, with the human author at least one step removed from the produced code. Surely, humans will need to enlist machines as collaborators for the interpretation of such code.) More importantly, and I hope this is not too vague, there are implications in the way code tries to perform a function that bear the imprint of epistemologies, cultural assumptions about gender, race, and sexuality; economic philosophies; and political paradigms. This list, however, does not begin to get at the more computer-specific issues.
除了少数写成诗歌的艺术品之外，大多数代码都与文学、电影和视觉艺术大相径庭，更类似于法律代码，因为文本是功能性的，主要是为了 "做 "而不是 "存在"，是为了执行而不是反映。然而，与法律代码不同的是，计算机代码通常被假定为人类肉眼无法看到的。然而，除了计算机生成的代码其程序员和用户从未见过的情况外，计算机代码通常会被其他程序员看到，他们必须对其进行修改。此外，即使代码只被程序员看到，就像被锁起来的日记或从未寄出的信件一样，它仍然是一种符号表达。(当然，计算机生成的代码将作者呈现为半机械人，人类作者与生成的代码至少有一步之遥。当然，人类需要让机器作为合作者来解释这些代码）。更重要的是--我希望这不会太含糊--代码试图发挥功能的方式中蕴含着认识论、关于性别、种族和性的文化假设、经济哲学和政治范式的烙印。然而，这份清单并没有涉及更多与计算机有关的问题。

Authorship is a much more complex issue in interpreting code than in traditional writing. Code frequently has multiple authors, mostly uncited, and large portions of code are adapted from previous code or code found online. Moreover, some of it is little more than boilerplate, at times autogenerated by an IDE. To use a common algorithm could be thought of as using a screw. Mechanics do not cite the inventor of the screw every time they use one, although programmers at times attribute code to particular sources. Nonetheless, literary analysis has found other means of dealing with questions of authorship, including the Foucauldian notions that the authors themselves are assemblages of influences. Simply put, it is not necessary to determine the author of a particular line to interpret the larger work of code. Meaning does not require
在解读代码时，作者身份是一个比传统写作复杂得多的问题。代码经常有多个作者，而且大多没有注明出处，大部分代码都是从以前的代码或网上找到的代码改编而来。此外，有些代码不过是模板，有时是由集成开发环境自动生成的。使用普通算法就像使用螺丝钉。虽然程序员有时会将代码归功于特定来源，但机械师不会每次使用螺丝钉时都引用其发明者。尽管如此，文学分析还是找到了处理作者身份问题的其他方法，包括福柯尔德关于作者本身就是各种影响的集合体的观点。简而言之，要解释代码的大作品，并不需要确定某一行的作者。意义并不要求
fingerprints. That said, if the writers publish their commentary, as in Terry Winograd’s SHRDLU, to name just one example, that commentary becomes a paratext that shapes the meaning of the code.
指纹。尽管如此，如果作者发表了自己的评论，比如特里-维诺格拉德的《SHRDLU》（仅举一例），那么这些评论就会成为塑造代码含义的副文本。

One of the problems with analyzing code is that its written expression represents only its static form before it has been processed. Code is at once what it is and what it does. That is not necessarily the same as saying that code is performative language in Austin’s sense, but rather to say that the static code represents a form of its existence before it is processed by the machine, whether it is compiled or not. As Wendy Chun (2011) has pointed out, the source code is not the same as the executable file. That said, the study of code requires not only reading the symbols but understanding that those symbols cause changes in state to software and hardware over a duration of time in dynamic engagement with other systems, including humans.
分析代码的问题之一在于，代码的书面表达仅代表其在处理之前的静态形式。代码既是它是什么，又是它做了什么。这并不一定等同于说代码是奥斯汀意义上的表演性语言，而是说静态代码代表了它在被机器处理之前的一种存在形式，无论它是否经过编译。正如温迪-春（Wendy Chun，2011 年）所指出的，源代码并不等同于可执行文件。也就是说，研究代码不仅需要阅读符号，还需要理解这些符号在与其他系统（包括人类）的动态接触中，会在一段时间内引起软件和硬件的状态变化。

Evan Buswell has been developing tools for annotating the state of a software system when it occurs, which gives the critic/reader/operator the ability to comment on the code in action, which we can also call the software. From a software studies point of view, such tools allow the reader the chance to identify states of the software in action. However, I consider this a principal aspect to reading the code because this state has been caused by the interaction of the encoded symbols with the system. Such readings of code in action are necessary due to the complexity of the interaction between the running code and the system (or other systems)—a complexity that often leads to states that cannot easily be predicted.
埃文-布斯韦尔（Evan Buswell）一直在开发用于标注软件系统运行状态的工具，这使得评论者/读者/操作者能够对运行中的代码（我们也可以称之为软件）进行评论。从软件研究的角度来看，这类工具让读者有机会识别软件的运行状态。不过，我认为这是阅读代码的一个主要方面，因为这种状态是由编码符号与系统的交互作用造成的。由于运行中的代码与系统（或其他系统）之间的交互非常复杂--这种复杂性往往会导致无法轻易预测的状态，因此有必要对运行中的代码进行这种解读。

Consider, by contrast, film. The individual frames of a film (on celluloid) interact with any given projector in predictable ways. Certainly there are variations in projectors (bulb brightness, motor speed due to wear); however, those variations are comparatively minimal. The action of the machine on the medium, shining a light through the celluloid, does not vary. Except when seeded by some unpredictable outside element, code also produces a predictable set of effects when processed. Nevertheless, the sheer complexity of the system makes the effects of code difficult to predict-one reason debugging is such a key part of programming. The operation of the machine upon the medium is not a straightforward activity, like the projection of film, but instead a set of interoperating processes enacted through and upon hardware. For this reason, analyzing code includes interpretation in the Saussurian sense of the signs and signifiers, but also analysis of this constantly shifting understanding of state.
相比之下，可以考虑胶片。胶片（赛璐珞）的各个画面与任何特定放映机的互动方式都是可以预测的。当然，放映机也存在差异（灯泡亮度、磨损导致的电机速度），但这些差异相对较小。机器对介质的作用，即通过赛璐珞发光，是不会发生变化的。除了受到一些不可预测的外部因素的影响，代码在处理时也会产生一系列可预测的效果。然而，系统的复杂性使得代码的效果难以预测，这也是调试成为编程的关键部分的原因之一。机器对介质的操作并不像放映电影那样简单明了，而是通过硬件并在硬件上执行一系列互操作过程。因此，分析代码不仅包括索绪尔意义上对符号和标记的解释，还包括对这种不断变化的状态理解的分析。

For perhaps a nearer analogy to code and executed software, consider blueprints. Although they may spell out the ingredients, a blueprint does not specify how the finished product will perform. True, any given platform will process the code in discrete and repeatable ways. However, the performance of the constructed object can be unpredictable, especially when human factors, such as users and operators, or realworld forces, such as heat or wind, are introduced. Because of that consistency and because that consistency is the necessary condition for software production and distribution, making and reading code relies on an ability to predict, produce, and test the states of the systems over the duration of the implementation (compiling, processing, and execution). Because of the complexity of these systems, full understanding of the code requires an understanding of the code in action.
如果要与代码和执行软件进行更接近的类比，可以考虑蓝图。虽然蓝图可能会详细说明其中的成分，但蓝图并不说明成品将如何执行。诚然，任何给定的平台都会以离散和可重复的方式处理代码。然而，所构建对象的性能可能是不可预测的，尤其是在引入用户和操作员等人为因素或热或风等现实世界的力量时。由于这种一致性，也由于这种一致性是软件生产和发布的必要条件，因此，代码的制作和阅读依赖于预测、生成和测试系统在执行期间（编译、处理和执行）的状态的能力。由于这些系统的复杂性，要完全理解代码，就必须了解代码的运行情况。

One of my early experiences with CCS may serve as a cautionary tale. When I proposed an incipient version of CCS to a group of programmers, one of them asked if I could prove CCS by applying these methodologies to a program with low natural language content, even in terms of input and output. The reviewer suggested Quicksort, an algorithm used for quickly ordering groups of numbers through a divide and conquer approach. In my early attempts at what Wardrip-Fruin would equate to interpreting a stop sign, I suggested Quicksort as a metaphor for social organization in communities, drawing out an analogy for the way a neighborhood street or even highway may serve to divide and conquer a demographic, for example through redlining. However, though my analysis said something about neighborhood hierarchies, it offered little insight on Quicksort itself, nor did it draw from Quicksort a lesson about the society from which it came. Here Hofstadter’s appeal to isomorphic analogies returns. My main error was analyzing Quicksort aside from its historical, material, and social context. For an algorithm such as Quicksort, the code meets the social realm at the site of its implementation and in the context of the application in which it is used. I was not engaging the cultural origins of Quicksort within the history of computation or even a particular incarnation of Quicksort in a language (I was using pseudocode). Without discussing the human context of the Quicksort code in terms of authorship, use, development, circulation, or operations, I was left with little more than an abstract process.
我早期使用 CCS 的一次经历可以作为一个警示故事。当我向一群程序员提出 CCS 的雏形时，其中一位程序员问我是否可以通过将这些方法应用于一个自然语言含量较低的程序，甚至在输入和输出方面，来证明 CCS。审查员建议使用 Quicksort 算法，这是一种通过分而治之的方法对数字组进行快速排序的算法。在沃德里普-弗鲁恩将其等同于解释停车标志的早期尝试中，我曾建议将 Quicksort 喻为社区中的社会组织，类比社区街道甚至高速公路可能通过划分红线等方式对人口进行分化和征服。然而，尽管我的分析对邻里等级有所涉及，但对Quicksort本身却没有提供什么见解，也没有从Quicksort中汲取有关社会的教训。在这里，霍夫斯塔德对同构类比的呼吁又回来了。我的主要错误在于脱离了Quicksort的历史、物质和社会背景来分析它。对于像 Quicksort 这样的算法来说，代码是在其实施现场和应用背景下与社会领域相遇的。我并没有探讨 Quicksort 在计算史上的文化起源，甚至也没有探讨 Quicksort 在某种语言中的特定化身（我使用的是伪代码）。如果不从作者、使用、开发、流通或操作等方面讨论Quicksort代码的人文背景，我只能看到一个抽象的过程。

Interpretation requires reading an object in its (post)human context through a particular critical lens. This context involves human machines operating in actornetworks. ${}^8$${}^8$^(8){ }^{8} Thus, a simple looping subroutine, say, might remind one of the eternal
解释需要通过特定的批判性视角，在（后）人类环境中解读对象。这种语境涉及在行为网络中运行的人类机器。 ${}^8$${}^8$^(8){ }^{8} 因此，比方说，一个简单的循环子程序可能会让人联想到永恒的......。
return of the repressed, but unless that metaphor has significance with respect to the particular, material context of the script itself, the interpretation will seem more of an imposition, a projection. That does not decrease its value but does signal less engagement with the production of code and its significance. However, if one found a recursive loop in a program designed to psychoanalyze its users, perhaps a connection could be drawn between recursion and the psychoanalytic view of the return of the repressed. Thus, though these computer programs are quite meaningful, like any cultural text, they yield meaning to the extent to which we interrogate their material and sociohistorical context, both immediate and more broad, and read their signs and systems against this backdrop.
但是，除非这种隐喻对剧本本身特定的物质环境具有重要意义，否则这种解释更像是一种强加，一种投射。这并不会降低它的价值，但却意味着对代码的生成及其意义的参与度降低了。不过，如果人们在一个旨在对用户进行心理分析的程序中发现了递归循环，或许就能在递归与精神分析的被压抑者回归观点之间找到联系。因此，尽管这些计算机程序与任何文化文本一样具有相当的意义，但它们所产生的意义取决于我们对其物质和社会历史背景（包括直接的和更广泛的背景）的审问程度，以及在此背景下对其符号和系统的解读。

Throughout this proposal, I have tried to highlight the moments in other critical writings when they have read specific coding elements because this is the kind of interpretation that is most lacking in analyses of codework and code. Cultural critics often speak abstractly of coding practices or the processes of code without getting to the code itself. My emphasis, however, should not understate the need for interpreting these structures with an eye toward fundamental human concerns, concerning race, ethnicity, gender, and sexuality; concerning the military-industrial-entertainment-academic complexes; concerning surveillance and control over electronic systems-to name but a few. Such readings will prove critical in the analysis of systems that do everything from facial recognition to tactical simulation of political systems to modeling human reasoning about peoples and places.
在整个提案中，我试图强调其他批评著作中解读特定编码元素的时刻，因为这是编码工作和编码分析中最缺乏的一种解读。文化批评家常常抽象地谈论编码实践或编码过程，而不涉及编码本身。然而，我所强调的不应低估对这些结构进行阐释的必要性，要着眼于人类的基本关切，涉及种族、民族、性别和性，涉及军事-工业-娱乐-学术复合体，涉及对电子系统的监视和控制--仅举几例。从面部识别到政治系统的战术模拟，再到人类对民族和地方的推理建模，这些系统的分析都离不开对这些问题的解读。

Since I first proposed this idea, some scholars have balked at the idea of reading code. There is simply too much code, they say. I cannot access the code of the object I want to study, they say. To the former complaint, I point back toward critical legal studies, which does not attempt to analyze every word of legal code but focuses its energies on particular moments and texts. To the latter, I point to literary history, in which so many texts have been lost to history, yet scholars continue to read and interpret what we have. Not everyone who studies digital objects will study the code, but to those who can, much meaningful communication and engagement awaits you.
自从我第一次提出这个想法以来，一些学者对阅读代码的想法表示反对。他们说，代码实在是太多了。他们说，我无法访问我想研究对象的代码。对于前一种抱怨，我回过头来看批判性法律研究，它并不试图分析法律条文的每一个字，而是将精力集中在特定的时刻和文本上。对于后者，我指的是文学史，在文学史中，许多文本已经消失在历史长河中，但学者们仍在继续阅读和解释我们所拥有的文本。不是每个研究数字对象的人都会研究法典，但对于那些有能力的人来说，许多有意义的交流和参与正在等着你们。

Many developments have transpired to make this the moment for critical code studies. First, higher-level programming languages are becoming readable to a wider population. The interactive fiction language Inform 7 is just one example. ${}^9$${}^9$^(9){ }^{9} Second, a growing number of critical theorists (and artists) are becoming literate in programming languages. Third, the programming community is beginning to consider aesthetics in
许多新的发展使得现在成为关键代码研究的时机。首先，更高层次的编程语言正在为更多人所接受。交互式小说语言 Inform 7 就是一个例子。 ${}^9$${}^9$^(9){ }^{9} 第二，越来越多的批判理论家（和艺术家）开始掌握编程语言。第三，编程界开始在以下方面考虑美学问题
a new way, which will no doubt lead to new styles of programming artistry. Fourth, colleges and universities are continuing to develop more programs in the humanistic analysis of science and scientific culture. Not least, works of code in art, art in code, codeworks, and electronic literature are proliferating, offering more moments of connection between represented signs and programmatic signs, as in the objects Cayley described earlier in ebr. Code increasingly shapes, transforms, and limits our lives, our relationships, our art, our cultures, and our civic institutions. It is time to take code out from behind quotation marks, to move beyond execution to comment, to document, and to interpret. Let us make the code the text.
这无疑将带来新的编程艺术风格。第四，高等院校正在继续开发更多对科学和科学文化进行人文分析的课程。更重要的是，艺术中的代码、代码中的艺术、代码作品和电子文学作品层出不穷，为表征符号和程序符号之间的联系提供了更多的契机，就像 Cayley 早些时候在 ebr 中描述的对象一样。代码越来越多地塑造、改变和限制着我们的生活、我们的人际关系、我们的艺术、我们的文化和我们的民间机构。是时候把代码从引号后面拿出来了，超越执行，去评论、记录和解释。让我们让代码成为文本。

This is a section of doi:10.7551/mitpress/12122.001.0001
本文是 doi:10.7551/mitpress/12122.001.0001 的一部分。

Critical Code Studies 关键代码研究
By: Mark C. Marino 作者： Mark C. Marino作者：马克-C-马里诺
DOI: 10.7551/mitpress/12122.001.0001
ISBN (electronic): 9780262357425
ISBN (electronic)：9780262357425
Publisher: The MIT Press 出版商：麻省理工学院出版社麻省理工学院出版社
Published: 2020 出版时间：2020 年

© 2020 Massachusetts Institute of Technology
© 2020 麻省理工学院
All rights reserved. No part of this book may be reproduced in any form by any electronic or mechanical means (including photocopying, recording, or information storage and retrieval) without permission in writing from the publisher.
保留所有权利。未经出版商书面许可，不得以任何电子或机械方式（包括影印、录制或信息存储和检索）复制本书的任何部分。

This book was set in ITC Stone Serif Std and by ITC Stone Serif Std and ITC Stone Sans Std by Toppan Best-set Premedia Limited.
本书由 Toppan Best-set Premedia Limited 采用 ITC Stone Serif Std 和 ITC Stone Sans Std 书写。

Library of Congress Cataloging-in-Publication Data
美国国会图书馆编目-出版数据
Names: Marino, Mark C., author.
姓名马里诺，马克-C.，作者。
Title: Critical code studies / Mark C. Marino.
标题：关键代码研究 / Mark C. Marino.
Description: Cambridge, Massachusetts : The MIT Press, 2020. | Series:
说明：马萨诸塞州剑桥 ：麻省理工学院出版社，2020 年。| 丛书：
Software studies | Includes bibliographical references and index.
软件研究 | 包括参考书目和索引。
Identifiers: LCCN 2019024253 | ISBN 9780262043656 (hardcover)
标识符：LCCN 2019024253 | ISBN 9780262043656 (精装)
Subjects: LCSH: Computer software–Social aspects. | Coding
主题：LCSH: 计算机软件-社会方面。| 编码
theory–Philosophy. | Programming languages (Electronic computers) |
理论-哲学。| 程序设计语言（电子计算机
Rhetoric. 修辞学
Classification: LCC QA76.9.C66 M628 2020 | DDC 005.3–dc23
分类：LCC QA76.9.C66 M628 2020 | DDC 005.3-dc23
LC record available at https://lccn.loc.gov/2019024253
立法会记录见 https://lccn.loc.gov/2019024253
$\begin{array}{llllllllll}10& 9& 8& 7& 6& 5& 4& 3& 2& 1\end{array}$$\begin{array}{l}10\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}9\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}8\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}7\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}6\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}5\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}4\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}3\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}2\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}\hspace{0.25em}1\end{array}${:[10,9,8,7,6,5,4,3,2,1]:}\begin{array}{llllllllll}10 & 9 & 8 & 7 & 6 & 5 & 4 & 3 & 2 & 1\end{array}