‘Can We Name the Tools?’ Ontologies of Code, Speculative Techné and Rhetorical Concealment

Introduction

/* No one is born happy. */
pcity -> ppl_happy [0] = 0;
city.c, FreeCiv

In her essay ‘Should We Name the Tools?’ Carolyn R. Miller identifies a contradictory impulse within the history of rhetoric. On the one hand, a rhetor strives to conceal the deliberate use of rhetorical art (techné) in order to maximize her persuasive influence because audiences distrust a palpable design. On the other hand, rhetorical pedagogy aims to reveal or name the workings of these hidden tools to guide the creation of rhetorical acts as well as to help educated audiences become aware of the concealed use of rhetoric in practice. In as far as rhetoric is a Gorgianic ‘power available to everyone,’ Miller invokes a distinction from the scholastics to declare that we face an ‘endless regress’ in which rhetorical pedagogy (rhetorica docens) actually lessens the effectiveness of rhetorical practice (rhetorica utens).¹ The former potentially creates a ‘cynical’ audience immune to the concealment and dissimulation of the latter.² What I will simply refer to as the ‘docens/utens problem’ accurately characterizes an underexamined aspect of the field of software studies’ call to examine code as an object of research in and of itself. Software studies emerged in part to counter ‘vapor theory’ (Lunenfeld) and ‘screen essentialism’ (Montfort) by revealing the technical (denominative or literal) meaning of code and its corresponding manner of execution.³ Pioneering scholarship by Lev Manovich helped to establish the analytical discourse of computer science as the authentic source of truth or meaning for computational media.⁴ Other descriptions of code tend to reflect Manovich’s understanding. For example, Alexander R. Galloway sought to reveal the literal and non-metaphorical protocol beneath the graphic-user interface as a form of revelatory critique.⁵

As Miller’s essay indicates, rhetoric’s historic interest in situating production (concealment) alongside analysis (revelation) helps to clarify how the effort to reveal the code beneath the screen impacts computational media’s subsequent usefulness for communication, expression, persuasion, and ‘procedural rhetoric’ (Bogost). If code is held to be immune from the dissimulating effects that plague other elements of computational media (screens), then code by definition can conceal nothing in critical revelation. One can always ‘name the tools’ of computational expression and, in turn, willfully conceal them. In accounts of code such as Manovich’s or Galloway’s, it is simply not clear how either scholar addresses the possibility of an endless regress in the shift from analysis to production. In other words, in identifying code as the primary source of meaning, rhetoric draws particular attention to the extent to which naming that code makes an audience immune to its concealment for persuasion. Researchers try to claim code as a critical tool only to potentially diminish its ability to be used to create forms of digital rhetoric to persuade others. This dimension is worth clarifying, because Galloway in particular argues for ethical and political ends for the revelation of code such as the exposure of how network protocols participate in the production of societies of control, and an endless regress would not be a very satisfactory outcome.

In introducing the history of rhetoric’s negotiation of docens/utens problem, my ultimate aim is to develop an alternative description of concealment and revelation for the understanding of code. Miller’s explanation of the docens/utens problem shares a point of overlap with certain aspects of software studies’ goal to reveal the operation of code by presupposing that concealment and revelation are intentional and cognitive acts of mastery.⁶ This classical presumption is common to many twentieth-century accounts of rhetoric, such as Thomas Cole’s. For Cole, rhetoric is ‘a speaker’s or writer’s self-conscious manipulation of his medium with a view to ensuring his message as favorable a reception as possible on the part of the particular audience being addressed.’⁷ From this perspective, code’s meaning or rhetoric is something that can be made visible and knowable and, in turn, willfully re-concealed as a rhetorical art.

Yet, phenomenological conceptions of technology starting from the German philosopher Martin Heidegger’s essay, ‘The Question Concerning Technology’ up through Mark B. Hansen’s Embodying Technesis remind us that the perspective of transparency and clarity is achieved only by downplaying or ignoring a more complex, embodied, and ontological cycle of presence (revelation) and absence (concealment). In a recent articulation, for example, Ian Bogost’s ‘alien phenomenology’ extends Graham Harman’s Heideggerian-infused object-oriented ontology to declare that the Being (substance) of any object is ontologically concealed.⁸ Regardless of our ability to perceive or manipulate code as means to an end or to experience its various sensual profiles, humans never fully exhaust the withdrawn but real ‘subterranean depths’ of code’s reality.⁹ Across these updated Heideggerian frameworks, concealment avoids the docens/utens problem by dramatically re-situating the agency of the coder whose productive affordances stem not from transcendental or epistemic knowledge but from pre-existing and dynamic forms of world disclosure (Erschlossenheit).¹⁰

To date, Wendy Chun’s Programmed Visions offers the most sustained and original treatment of code along related lines.¹¹ Chun urges software studies not to examine code with the aim of revealing its authentic being, but to learn to appreciate the essential ‘deviousness’ of code by contending with its iterability—its material, spatial, and temporal enactments and instruction. Her deconstructive reading holds that the vapory stuff that software studies implicitly tries to exclude in order to name code as a tool is actually central to code’s ontological reality as ‘thing.’ Intriguingly, Chun offers a single reference to rhetoric.¹² She refers to a ‘speculative techné’ of code via Paul Ricoeur and curiously abandons any further discussion of code’s rhetorical character.¹³ If I might engage in my own deconstructive maneuver, Chun’s marginal reference underscores the fundamentally rhetorical nature of her book’s argument.

By demonstrating that certain aspects of software studies’ revelatory critique occurs by maintaining absolute binaries between the literal and metaphorical or technical and vapory, Chun’s work indicates that some conceptions of code within software studies are covertly engaged in replaying an ancient battle between rhetoric (troping, dissimulation, deviousness, appearance, sophistry) and Platonic philosophy (transparency, visibility, logic, truth). By inverting and re-casting these binaries, Chun’s work also directly complements ongoing work by U.S. rhetorical theorists to define rhetoric not merely as argumentation, claims, language, discourse, or epistemology, but as a pre-symbolic, pre-subjective, or affective ontological relationality with the ongoing disclosure of the material world. Echoing yet extending the arguments of postmodern figures such as Paul de Man, Ernesto Grassi, and Hayden White beyond language, rhetorical studies scholars such as Thomas Rickert have argued that rhetoric (troping) is ontologically prior to the Platonic logos (topoi, logic), and by extension serves as a concealed but real condition of possibility for the rhetoric of code.

In this regard, a major contribution that an engagement with contemporary rhetorical theory offers software studies is the ability to situate code’s revealable technical operations alongside its concealed temporal, material, and rhetorical enactments and speculative conditions of possibility in order to acknowledge and yet reconceive of rhetoric’s endless regress. In contrast to Miller’s fear, code as concealed thing indicates that coders never fully reveal or unconceal code through knowable forms of philosophy, rhetoric, technical description, or representation. By extension, code becomes an occasion to better theorize the human-technology-world relationship while working toward an ontologically accurate notion of the composition of reality through the diverse agencies and affects of human and computational actors. When concealment is an ontological property of code, rhetorical utens through code can still be exercised within these pre-symbolic relations of affectivity. Docens, however, must teach that human agency and cognition alone are never completely responsible for the revelation or concealment of all rhetorical effects in code.

As a case study, I will offer a brief but hopefully suggestive reading of ontological concealment in the code of the videogame FreeCiv 2.0, the opensource equivalent of Sid Meyer’s Civilization II.¹⁴ In part, the 2.0 update attempted to control or curtail the universally abhorred ‘infinite city sprawl’ (ICS) strategy for empire building. FreeCiv’s freely available and revisable code demonstrates multiple rhetorical dimensions of code in the fight to stem ICS such as notational commentary, patches, mods, and collaborative approaches to coding that reflect code’s iterability and para-textual nature.¹⁵ Ontological concealment nevertheless confirms that any isolated part or extractable rhetorical meaning within FreeCiv’s code only takes its bearing and individuation from the particular way in which it is given in the whole—the entangled thing-ness of code, coders, player communities, mediums, networks, and many other material factors and temporal relations. My analysis concludes that code in videogames like FreeCiv or any computational medium should remain a critical aspect of interpretation but these analysis also need to be connected to the ways in which code attunes (Stimmung) researchers to the ongoing unconcealment of the world that functions as the ‘background of intelligibility and practical coping from which we work.’¹⁶

The docens/utens Problem

Miller’s essay explores the consequences of two opposing tendencies within the history of the study of rhetoric. On the one hand, much in contemporary rhetoric follows the tendency of Plato’s Gorgias ¹⁷ or Cicero’s Crassus toward rhetoric’s self-aggrandizement.¹⁸ The power in persuasive speech is held to have great power ‘to raise up those that are cast down, to bestow security, to set free from peril, to maintain men in their civil rights’ while also granting individuals capacities to speak on any subject.¹⁹ In the twentieth-century, rhetoric’s rise to disciplinary prominence in the U.S. lies in offering similar and, in many cases, stronger claims of self-aggrandizement. Richard Cherwitz and Charles A. Darwin write, ‘one of the assumptions implicit in much of contemporary rhetorical theory is that there is no way to ground representations of reality (rhetoric) in a reality independent of discourse.’²⁰ The ‘everything is rhetoric’ attitude can clearly been seen in the rhetorical theorist Kenneth Burke’s frequently cited maxim, ‘something of the rhetorical motive comes to lurk in every ‘meaning,’ however purely ‘scientific’ its pretensions. Wherever there is persuasion, there is rhetoric. And wherever there is ‘meaning,’ there is ‘persuasion.’’²¹ As a result, rhetoric’s domain now extends to the generation and invention of scientific discourse and the production of cultural identities and meanings.

On the other hand, Miller describes how a countervailing tendency exists within rhetorical history toward self-denial: ‘ars est artem celare.’²² Rhetoric has to appear in practice to be genuine, spontaneous, and unrehearsed. Aristotle says, ‘Authors should compose without being noticed and should seem to speak not artificially but naturally. (The latter is persuasive, the former the opposite).’²³ Quintilian offers a similar refrain: ‘if an orator does command a certain art . . . its highest expression will be in the concealment of its existence.’²⁴ Michael Cahn suggests that concealment means a great deal more than the mere dissimulation of intention. Rather, at the ‘very heart of rhetoric . . . is the conviction that the means by which intentions are concealed must also remain undetectable . . . it is a dissimulation of means as much as of ends.’²⁵ In Plato’s dialogues, the requirement for concealment indicates precisely the way in which rhetoric is different from other arts that he often compares to rhetoric. We can enjoy the products of medicine, navigation, or cookery while knowing quite a bit about their techniques, materials, and modes of production. Rhetoric is more like seduction, cosmetics, hunting, and military strategy. With cosmetics, Miller writes, ‘[w]e admire the skill involved in exercising the art rather than the appearance of the wearer, the art itself rather than its results.’²⁶

Given this tension, Miller questions whether rhetoric’s educational aims will not actually end up undermining rhetoric’s effective use. She writes,

But is there not a contradiction here? . . . If citizens become more critical judges of rhetorical practice, they should also become more cunning practitioners themselves. Yet, the strategies of the cunning practitioner will increasingly be revealed by the increasing critical acuity of the citizen audience. We seem to have another endless regress, a continual escalation of cunning concealment and critical unmasking.²⁷

Miller in no way advocates abandoning rhetorical or critical education such as training in code; indeed, such compromises between revelation and concealment are inevitable to the teaching and transmission of any disciplinary knowledge. Similarly, many would readily accept the tradeoff of lessening rhetoric’s expressive power by naming the tools to help students avoid ‘bad rhetoric’—pandering or manipulation. Scott Consigny via Wayne Booth writes, ‘A rhetoric based on concealment is extremely dangerous, for ‘an open society living by a rhetoric of deception cannot long endure.’ What is needed [this approach to concealment assumes] is a rhetoric which discloses truth, rather than one which conceals facts and good reasons in a given case.’²⁸ In the end, Miller deliberately offers no resolution to this contradiction, as her aim is to pay homage to rhetoric’s ancient power and danger. As Brian Garsten memorably notes, we may never entirely avoid the dangers of manipulation or pandering that come from the nature of rhetoric if rhetoric is to be employed as a powerful persuasive art.²⁹

Revealing the Rhetoric of Code

To place the docens/utens problem in the context of software studies requires a slightly different point of emphasis than Miller’s. Echoing Manovich’s pioneering work,³⁰ scholars like Bogost, Mark Marino, Nick Montfort, Matthew G. Kirschenbaum, Lisa Gitelman, Mark Sample, and many others have argued that software studies has to focus both on the output and expressive capacities that code enables for end-users—’the digital event on the screen’—and the actual execution of the code itself.³¹ Peter Lunenfeld famously rejected ‘vapor theory,’ which he defined as ‘dialectical immaterialism, discussions of technology untethered to the constraints of production.’³² Picked up by Manovich, Lovink, and Galloway, vapor theory as a metaphor separated computer science’s technical description of code as material (substance, essence, authentic) from approaches within new media studies that focused on the screen as immaterial (appearance, inessential, inauthentic) in search of what can be fixed as a hermeneutic center. To be clear about this point, the call to banish vapor theory does constitute a turn toward the materiality of technology. However, code is granted materiality only in so far as code’s technical and literal nature is the object of analysis.

Across these arguments, knowledge of code’s technical operation through computer science enables critical theorists to leave Plato’s cave and distinguish between screen and code, immaterial and material, demo and product, or fiction and reality. Galloway, as I noted above, specifically demarcates the space between the ‘literal’ (code) and ‘metaphorical’ (screens).³³ He forcefully declares, ‘code draws a line between what is material and what is active, in essence saying that writing (hardware) cannot do anything, but must be transformed into code (software) to be effective. . . . code is the first language that actually does what it says.’³⁴ Unlike the graphic interface (metaphor), code cannot dissimulate or conceal its art in execution. In Galloway’s interpretation, software is like a neatly layered recipe that can be fully understood and revealed.

The revelation of code’s technical operation fulfills not rhetorica but, if I may, ‘logica docens’: a Kantian release from the self-incurred tutelage of vapor theory. One clear pedagogical example lies in critical theorists’ reaction against the software industry’s desire for transparency: the belief that users want the computer to be invisible or simplified in use, as is the case with graphic user interfaces in which the user never needs to encounter code. This tendency means that the user will never encounter the code and therefore commercial interfaces strive to mask (dissimulate) their mechanisms of protocol, surveillance, and control ‘exactly when the user needs to see and understand what the system is doing.’³⁵ It is not much of a stretch to see in these conversations the legacy of Socrates’ classical distinction between good and bad rhetoric. As Consigny describes, rhetorical scholarship ‘from Socrates to the present have distinguished good rhetoric, an attempt to disclose and communicate the truth in unbiased, reasoned speech from bad rhetoric, the use of weighted language and specious argumentation to conceal facts and bolster one’s cause.’³⁶ Galloway implicitly equates ‘bad rhetoric’ (sophistry, manipulation) with the transparent interface that disguises neoliberal control for the end user. The dissimulating interface and the concealment of code is akin to an ‘adulterated wine’—a description of the powers of rhetoric that Aristotle makes.³⁷ End users therefore often find it uncanny when the coded ‘tools’ that sustain the interface are visually ‘named’ in artistic projects such as Ben Fry’s Deconstructulator, which visualizes the compiler’s real-time perception of the code in Super Mario Brothers for NES alongside the player’s actions in the game.³⁸ Good rhetoric then involves media interfaces that require specific self-conscious awareness of the underlying code and protocols while bad rhetoric assumes that the medium should strive to conceal its tools from the user by attempting to become completely transparent in use.

While logica docens seeks to immunize code from concealment and dissimulation, a growing number of rhetorical approaches to code have carved out a space for rhetorica docens primarily through rhetoric’s epistemic self-aggrandizement.³⁹ Code in execution undeniably lacks the figurative range of spoken or written languages. However, the composition of source code involves idiosyncrasies of individual coding styles, justifications for patches/corrections in notational commentary, a variety of procedural rhetorics, and even the rhetoricality of platform or coding language selection. Alexandria Lockett notes how non-native English-speaking coders must engage code-switching literacies in software across versions of English.⁴⁰ Focusing on the interplay between semiotic systems and rule-governed procedures has enabled scholars to integrate procedural literacies as a form of writing.⁴¹ Kevin Brock encourages researchers to view ‘code as a significant rhetorical component of textual creation and performance rather than simply a vehicle to transmit a text to an audience,’⁴² and Teena A.M. Carnegie suggests that it is necessary to consider the possible range of rhetorical interactions for audiences and rhetors that exist within each layer: uncompiled source code, execution, and expression.⁴³ All of these elements impact a rhetor’s ability to control or delimit a range of potential meanings in order to persuade an audience.

In stark contrast to Galloway’s claim that ‘code essentially has no other reason for being than instructing some machine in how to act,’⁴⁴ Mark Sample ‘close reads’ videogame code akin to how a literary critic close reads a work of fiction. He similarly views code as an iterable ‘text’ that contains multiple forms of expressive (e.g., rhetorical) signification.⁴⁵ In Micropolis, the opensource version of SimCity, only the police levels in a player’s city impact crime. The game makes a procedural argument that other potential mitigating factors (city watch groups; rehabilitation) have no impact. By examining the code, Sample teases out nuances to the procedural argument that the player may never consciously realize, such as the fact that a ‘populous neighborhood with little police presence can never be crime-free.’⁴⁶ Sample also explores what Marino calls code’s ‘extra-functional significance’ in notational commentary. One notational comment in Micropolis indicates how Electronic Arts removed one randomly spawning disaster—a plane crashing into tower—after 9/11. Such comments signify, but ‘aren’t intended for the end-user.’⁴⁷ They are literally concealed from the player and the compiler alike.

Miller’s essay could easily lend support to the crucially important pedagogical project of teaching students to name new tools such as notational commentary as a form of critical revelation or rhetorical training. Yet, her essay also makes us consider how the self-aggrandizement of the rhetoric of code in docens results in the potential for endless regress with respect to many scholars’ clear goal of utens through code. Echoing Collin Gifford Brooke, Brock maintains, ‘A goal of [digital] rhetoric then is to understand exactly how language [or code] influences certain possibilities to become realized over others when used by a rhetor in a particular situation.’⁴⁸ rhetoric of new media, rather than examining the choices that have already been made by writers, should prepare us as writers to make our own choices.’] Furthermore, the fact that the docens/utens problem comes into play simultaneously tells us even rhetorical accounts of code overwhelmingly reflect and privilege the modes of revelation grounded in consciousness, visibility, and epistemology. While it is true that understandings of good and bad rhetoric have become more expansive and less binary since Plato’s complaints, Richard Scot Barnett’s broad claim remains uncannily accurate:

the assumptions [of modern and postmodern] rhetoricians continue to hold about concealment have nevertheless tended to remain the same: that concealment . . . is above all a direct consequence of human discursive action in the world and that, as such, constitutes something speakers or writers can learn to recognize, instrumentalize, and, in certain cases, will into or out of concealedness.⁴⁹

This observation, again, is not to suggest that scholars interested in code should stop revealing code’s technical and rhetorically expressive dimensions. It is more to observe that if our aim is to reveal the rhetoric of code beneath the screen to raise critical consciousness and aid our productive activities, then, at the same time, Miller would urge software studies to consider how our efforts necessarily participate in the project of immunizing rhetorically educated citizen-coders from rhetoric’s true source of power which lies in hiding the tools.

Unconcealing the Ontology of Code

One way to begin reconsidering this problem is to question whether code’s reality is concealed or set into motion entirely by human will. In his unpublished doctoral dissertation, Barnett convincingly argues that concealment in rhetoric could benefit from phenomenological considerations. While he does not extend his observations to code, Barnett productively explores what it might mean if concealment were an ontological condition of rhetoric and not merely a learned capacity of coders to reveal or conceal certain aspects of reality. What if instead, he wonders, concealment echoed Heidegger’s agreement ‘ ‘to let concealment be’ and in so doing affirm in our letting-be the absent presence of an inexhaustible concealment at the core of all beings in the world, human and nonhuman alike, that cannot be grasped, controlled, or transcended but which nevertheless bears considerably on the rhetorical relations we have with technical objects, human others, and the world itself?’⁵⁰ Simply put, if a passive and fully present object (code) does not in fact oppose a willfully revealing and concealing subject (rhetor-programmer), then the docens/utens problem can be rearticulated.

Chun’s Programmed Visions offers a significant contribution along these lines by offering a specific exigency to shift the conception of code beyond appearance—literal, figural, or epistemic—signification to better account for the computational relations that transcend the critic’s interpretative (revelatory) capacity. I am unable to do justice in this limited space to the richness and complexity of her argument. Among other aspects, Chun explores the historical production of code through its parallels with genetics, the gendered and military history of computing, and neoliberal personalization of power. I will largely confine my discussion to her chapter, ‘On Sourcery and Sourcecode,’ in which she directly criticizes the tendency of certain researchers like Manovich or Galloway in software studies for achieving critical and hermeneutic clarity in code by maintaining a separation of code’s instruction from its machinic execution.

Chun documents how commercial and proprietary interests contributed to the need to establish a true essence of code, converting ‘programming’ (verb) from a service and temporal process to a noun—’program’—that designated a fixed, stable, visualizable, and knowable ‘thing’ (a conceptual distinction I will return to momentarily).⁵¹ Code as thing becomes logos or the authentic representation of computational action. Chun observes, ‘Like the King’s speech in Plato’s Phaedrus, [the logos] does not pronounce knowledge or demonstrate it—it transparently pronounces itself.’⁵² Software becomes ‘the end all and be all of computation and putting in place a powerful logic of sourcery that makes source code—which tellingly was first called pseudocode —a fetish.’⁵³ Her play on words with ‘sourcery’ calls attention to the magical desire of the sovereign programmer who, like a pre-enlightenment magician, desires to have his words instantly become action in the world.
Chun expresses concern over the tendency by some in software studies to retain the concept of source code as logos by banishing what is vapory, ephemeral, or temporal. In a comment of clear interest to the classical rhetoric/philosophy divide, she identifies a consequence of the ways in which researchers in software studies embraced the purely technical analysis of code as a way to resist vapor theory or screen essentialism. Such a move tends to ‘reify knowing software as truth.’⁵⁴ Chun maintains, ‘As advocates of free and open source software make clear, this critique aims at political, as well as epistemological, emancipation. As a form of enlightenment, it is a stance of how not to be governed like that, an assertion of an essential freedom that can only be curtailed at great cost’.⁵⁵ Those who know code can avoid bad rhetoric’s concealment (protocological or corporate manipulation), and yet maintaining code as logos nevertheless accepts the commodification of code’s separation between source code and execution or instruction and result. Code remains divorced from certain structures of knowledge-power. Linking autonomy and freedom to open source code ‘amplifies the power of source code both politically and technically. It erases the vicissitudes of execution and the institutional and technical structures needed to ensure the coincidence of source code and its execution.’⁵⁶ While they engage power differently, free and open source software does not avoid power. For example, Copyleft or GNU participate in the privatization of the public domain by ‘seek[ing] to fight copyright by spreading licenses everywhere.’⁵⁷

Chun’s use of the term ‘thing’ to describe a fixed and stable code is sure to initially frustrate any reader familiar with Heidegger. For Heidegger, ‘object’ is the name for the fixed, present, and stable Cartesian-Newtonian entity and ‘Thing’ designates the unconcealed, ecological, and withdrawn reality of objects.⁵⁸ In my view, Chun deliberately plays on this tension so that she can seamlessly slide from ‘thing-as-object’ to ‘Thing-as-unconcealed essence’ without directly stating the shift, thereby performing the oscillation between object and Thing, and reminding us of Chun’s point that ‘every move to empower [e.g., to know code] also estranges.’⁵⁹ Since the total revelation (knowledge) of source code maintains code’s separation from power and historical production, Chun makes a deconstructive maneuver to suggest that we can never fully reveal code and that source code cannot be conflated with either its process of execution of its executable version.⁶⁰ The vapory, withdrawn, and iterable elements that both commercial forces and software studies criticism sought to exclude are actually inseparable from the Being of code. Chun telling describes software and computers as a ‘metaphor for metaphor itself.’⁶¹ In a literal sense, this claim is true because software ‘encapsulates a general law of substitutability’ and promises to provide programmers with a means of grasping the nature of all of computational processes through a common language of software.⁶² However, in contrast to Aristotle’s claim in the Rhetoric that metaphor will ‘set things before the eyes’ of an audience, Chun counters that software actually ‘… troubles the usual functioning of metaphor, that is, the clarification of an unknown concept through a known one. For, if software illuminates an unknown, it does so through an unknowable (software).’⁶³

To offer one example of the “unknowable” essence of code, she challenges Galloway’s claim of the logical equivalence between uncompiled source code and the compilation of the same code into machine code or assembly language. Galloway writes, ‘it is absurd to claim that a certain value expressed as a hexadecimal (base 16) number is more or less fundamental than that same value expressed as binary (base 2) number.’⁶⁴ There is nothing ‘empirically different’ about higher and lower symbolic interactions with respect to the voltages that pass through logic gates. He continues, ‘It is foolish to think that writing an ‘if/then’ control structure in eight lines of assembly code is any more or less machinic than doing it in one line of C, just as the same quadratic equation may swell with any number of multipliers and still remain balanced.’⁶⁵ He emphatically declares that the ‘relationship between the two is technical’ and immune from concealment in any form.⁶⁶

In contrast, Chun suggests that a technical relationship glosses over coding as a materially enacting and temporally unfolding process. She writes, ‘This reduction, however, does not capture the difference between the various instantiations of code, let alone the empirical difference between the higher symbolic machine and the lower interactions of voltages.’⁶⁷ Furthermore, she maintains that code is not simply ‘run,’ but compiled and interpreted, and this is ‘not a trivial action.’⁶⁸ Executability is not the same as the translation from a decimal into a binary. The ways in which the material and actual processes occur must utilize instruction explosion while converting symbolic figures into real addresses. She explicates the instructions for adding two numbers in PowerPC assemblage language (one level higher than machine language), commenting that the explosion is by no means logically equivalent to the mathematical function of multiplying the two sides of a quadratic equation, but instead ‘focuses on the movement of data within the machine.’⁶⁹ Crucially, there is no mathematical identity then between executable and higher-level code, but ‘logical equivalence, which can involve a leap of faith.’⁷⁰ Furthermore, the object and source of code always differ because an object of code is always embedded within an operating system.

In making this observation, Chun has begun to ‘unconceal’ the withdrawn element of code’s unknowable Thing-ness. In stark contrast to Galloway’s understanding of technical, coding in consideration of its material enactment—programming as a verb and unfolding process—becomes technical more in the sense of the ancient Greeks’ concept of techné. Coding, then, is not a fully willful act of revelation or concealment, but rather ‘the technique of providing a dynamic background to control the automatic evolution of a meaning.’⁷¹ In her brief and tantalizing reference to rhetoric, she invokes Paul Ricoeur’s quotation that ‘techné is something more refined than a routine or an empirical practice and in spite of its focus on production, it contains a speculative element.’⁷² Source code’s essence is not reducible to human manipulation but serves instead as a co-productive ‘re-source’ that points back to the fact that our agentive actions and understandings can only proceed from the traces of code’s prior iterability. She concludes, ‘Source code becomes a source only through its destruction, through its simultaneous nonpresence and presence’ that exists, in her memorable description, somewhere between living speech and dead repetition.⁷³

In no small coincidence, the King’s speech in the Phaedrus that supports code as logos simultaneously dismisses rhetoric as sophistry by comparing it to cookery, makeup, hunting, and, tellingly, concealment (cunning, deception, dissimulation). Thus, one major implication for Chun’s speculative techné is that many in software studies are indeed unwittingly playing out the classical debate between rhetoric and (Platonic) philosophy. In this regard, Chun’s argument offers perhaps the strongest argument outside of the rhetorical tradition to date for exploring the relationship between rhetoric and the analysis and production of computational media and code. Programmed Visions demonstrates that current theoretical approaches within software studies share significant points of overlap with ongoing work by U.S. rhetorical theorists. Since rhetoric appears only in the margins of her text, another deconstructive turn can demonstrate that what is marginal in her text is actually the central aspect of her argument. In seeking to restore code’s material and temporal iterability, but without allowing us to fully know or reveal its essence, Chun demonstrates without directly positing it a vision of rhetoric akin to D. Diane Davis’s articulation of ‘an originary (or preoriginary) rhetoricity—an affectability or persuadability—that is the condition for symbolic action.’⁷⁴ Davis uses Emmanuel Levinas’s thinking as an example, suggesting that communication can only occur ‘among existents who are given over to an ‘outside,’ exposed, open to the other’s affection and effraction.’⁷⁵ The very idea of communication presupposes that we cannot fully know (reveal) the Other. As a result, these pre-symbolic forms of affect—the unassimilablity of the Levinasian Other—serve as the condition of possibility for communication. Davis maintains that this call to respond is fundamentally rhetorical, regardless of the fact that Levinas did not use the term ‘rhetoric.’ She writes,

the existent (the ‘subject’) emerges as such only in response to alterity and therefore exists for-the-other (nonindifference) before it ever gets the chance to exist for-itself (indifference) . . . What Levinas shows without seeing is that rhetoric is first philosophy. Not (only) because the generative power of the trope is the ground for all thought as Ernesto Grassi would have it, but because a nonsubjective persuasive appeal is what calls for tropological intervention each time.’⁷⁶

Simply put, no amount of docens will ever reveal the Other’s essential rhetorical character. Rhetorical ontology is prior to the Platonic or enlightenment philosopher cum programmer’s willful revelation.
At the same time, code is a nonhuman actor and not a conscious human Other (excepting perhaps the dream of perfect AI). Thomas Rickert points to Davis’s comment about Heidegger who writes, ‘there is no being that is not already being-with, no Dasein that is not already mitsein [Being-with] or Mit-da-sein.’⁷⁷ Thus, the effective use of persuasive means (words, algorithms), presupposes that ‘a more originary rhetoricity must already be operating, a constitutive persuadiblity and responsitivity that testifies, first of all, to a fundamental structure of exposure [to the World].’⁷⁸ Rhetorical ontology (concealment) is no longer self-aggrandized in the production of knowledge, but instead ‘[treats] with the way humans beings are . . . Rhetoric is an emergent result of environmentally situated and interactive engagements, redolent of a world that affects us, persuades us prior to symbolicity.’⁷⁹

This ontological view of concealment dramatically re-shapes some of the ways in which software studies theorists have examined software and code. When Adrian Mackenzie describes software as a ‘neighbourhood of relations’ whereby in code and coding ‘relations are assembled, dismantled, bundled and dispersed within and across contexts,’ rhetoric is not simply located in its individual and separable parts (notational commentary, electricity, gravity, keyboards, screens, humans, code).⁸⁰ Rather, neither humans nor nonhumans ever ultimately become individuals because we never lose or shed this prior affectability. In an implicit reflection of this fact, Chun observes that we cannot even foresee in advance or completely predict the sequence of code because code is always dependent on intermediate results.⁸¹ Code retains this pre-symbolic affectability depending on its specific mode of comportment with respect to various involvements of other actors within its unfolding phase space.

Utens/docens consequently shifts from a problem grounded in critical revelation and epistemology or visibility to an ontological mode of attunement to what code discloses and conceals in its gathering as concealed thing. The programmer does not willfully reveal or conceal the tools of code, but is instead involved in a series of ongoing attunements or feedback loops between individual agency and an always withdrawn pre-symbolic distributed agency of code that never fully unconceals. By extension, researchers and teachers of computational media should indeed help students to name the tools of code, but also refuse to equate naming and appearance with means-ends or cognitive/epistemic revelation alone. Galloway and Manovich are correct that we need to examine code’s technical functioning, and Sample is also correct that we should name the tools of code’s multiple layers of expressive signification. However, Programmed Visions emphatically reminds researchers to be wary of reinscribing rhetoric to philosophy by separating the worldliness of instruction from execution. We must also learn (docens) to ‘play with’ vapory elements of code’s ontological concealment and to take ‘pleasure’ is ‘things that do not end when they should’ in order to attune ourselves to a more ontologically rich or complete vision of human and nonhuman Being.⁸² Ontological concealment attunes itself to what is present and what is concealed as the condition of possibility for us to perceive and understand the world. It is true that we do not have to understand all of these factors to engage in rhetorical activity or to write code. Nevertheless, learning about these unintentional symbolic and non-symbolic elements and resonances allows us to understand a more complex and fuller picture of how meaning and persuasion emerge from our material and temporal relations within code.

Revealing and Unconcealing Smallpox

In large part because of Civilization’s popularity among game studies theorists and its freely available code, the FreeCiv players’ and developers’ rhetorical responses to the Infinite City Sprawl (ICS) epidemic offers a compelling case study for ontological-rhetorical concealment. Three students from Aarhus University, Peter Unold, Claus Leth Gregersen, and Allan Ove Kjeldbjerg, created the first playable version of FreeCiv (version 1.0). Modeled after Meyer’s Civilization II, the videogame was initially released in 1996 under a GNU General Public License as free and open source software. FreeCiv’s use of C programming language and its intentionally portable design enabled rapid development across numerous platforms. In FreeCiv, players start in the year 4000 B.C. as tribal leaders and aim to build an empire in a competitive environment (versus AI or other players), and winning occurs when all other opponents’ civilizations have been destroyed, when space colonization has been achieved, or when a player has the most valuable civilization after a certain specified time period. Given that its last stable release (version 2.4.4) occurred in January 2015, FreeCiv still enjoys a great number of players who are drawn to its nearly limitless configurability. FreeCiv offers players the ability to act as game administrators, to collaboratively modify game rules, and, to code unique rulesets or other content.

At the level of procedural rhetoric, the code offers clear support for ICS. Among other factors, the success of an empire depends upon the emotional states (happy, angry, content, or unhappy) of its citizens. After each turn, all relevant variables that impact (positively or negative) citizens’ emotions are calculated and the ability to build or produce in new directions is enabled or constrained by the emotional states that are returned. In the 1.0 versions’ government.ruleset, cityfactor by default is 14.⁸³ Cityfactor establishes the most number of cities that a player can build without encountering the unhappy limit. By default, three citizens will always be content in a given city without forcing the player to invest in luxuries, improvements, or wonders. If a player wants cities that operate in more than four terrain squares each, she will have to anticipate changes to morale and invest in resources to ensure positive emotional states. Another part of the ruleset, empire_size, automatically increases the number of unhappy citizens with respect to the total number of cities that the player builds. The total number of unpenalized cities is subtracted from cityfactor and depends on the type of civilization: Anarchy (-5), Despotism (-4), Monarchy (-3), Communism (-2), Republic (-1), and Democracy (0).⁸⁴ Once a player builds a twelfth city under Monarchy, then every fourth citizen in each city becomes unhappy, and the player is required to spend resources on luxuries. Since a single unhappy worker moves a city into disorder (which limits production to luxury and increases the likelihood of revolt), ICS players keep a vast number of small cities under three tiles and gain a real advantage because they never go over the unhappiness limits. They never have to invest in improvements and can exclusively build attack units.

In partial response to ICS, the 2.0 version in 2005 included significant changes to core game mechanics to make it worthwhile for players to develop a handful of large cities with advanced technologies and trade routes, rather than employing numerous small towns.⁸⁵ To determine the rhetorical response to ICS, we could simply reveal the literal changes to the code that attempted to mount different procedural claims. FreeCiv Wikia notes that adjustable server elements for determining citizens’ emotional states such as empire_size_mod, cityfactor, angrycitizen, and unhappy limits (unhappysize) were removed in 2.2 updates and replaced with empire_size_base and empire_size_step—rulesets that more directly penalized larger empires by adding one additional unhappy citizen when the number of cities grows past a default number regardless of the size of a player’s various cities.⁸⁶
Yet, the rhetorical treatments of code that I discussed above indicate that FreeCiv’s code is irreducible to its literal or automatically executing elements alone. In actuality, analyzing these added components’ technical operation (in Galloway’s sense) by separating instruction from execution is quite difficult to achieve given FreeCiv’s opensource status. What makes FreeCiv both an interesting and yet difficult case study for concealment is precisely the fact that its coding community and networked archives already reveal a broad range of rhetorical, social, and expressive dimensions. Players are perhaps too aware of the code that structures their expressive and procedural experience of the game’s arguments on the screen. Players actively negotiate with one another about making server adjustments to play options such as the overall size of the map or the chance percentage of certain resources or items being contained within a given territory space. While many videogames offer players the ability to adjust settings, FreeCiv’s opensource nature blurs the boundaries between players and coders. The FreeCiv Wikia notes, ‘The ruleset files in the data directory are user-editable, so you can modify them to create modified or custom rulesets without having to recompile FreeCiv.’⁸⁷ Even a player with little coding knowledge can readily locate and adjust many of the default ruleset settings. Indeed, Mike Jing—a player with little coding skill—published an infamous and polemical 2003 essay on FreeCiv Wikia in response to the ICS spread. He offered an excellent argument for altering core game mechanics to eliminate ICS.⁸⁸

FreeCiv’s coding manifesto also calls into question the warrant of the all-knowing programmer and the automatic executability of the code: ‘Basically, we believe in the power of distributed software development, and the tenet that ‘to an infinite number of eyes, all bugs are shallow.’’⁸⁹ Individual agency is considered grossly inferior to the distributed or crowdsourced agency of collective of programmers and players. This collaborative design community necessarily requires that rhetorical decisions and justifications accompany any change to code through patches, mods, or rulesets. In a clear acknowledgment of both code’s extra-functional significance as well as the rhetoricality of different programming styles and approaches, the ‘Style’ instructions read, ‘The description of the function should be here. Also describe what is expected of the arguments if it is not obvious. Especially note down any non-trivial assumptions that the function makes. Do _not_ introduce a new function without some sort of comment.’⁹⁰ This instruction set affirms Chun’s claim that ‘code does not do what it says it does: while also embodying a more complex expression. Simply put, code will do what it says it does to a nonhuman reader (the compiler) but will not do what it ‘says’ to a human reader. Decisions about trivial versus non-trivial are clearly dependent on a programmer’s assumptions about audience and require becoming familiar with the normal knowledge of the FreeCiv community. Thinking back to Sample’s essay, notational comments in FreeCiv are often expressive in addition to denominative. The code reveals that converting a worker to an entertainer is often dubbed an ‘elvis’—a metaphor and not a literal description.⁹¹ We also find evidence of ‘bro-grammer’ humor intended for a male programming audience in a notational comment that dubs a city in Rapture the ‘XXX Days.’⁹²

FreeCiv is akin to a perpetually revealed blackbox across its multiple layers of rhetorical expression. FreeCiv’s documentation archives are also replete with literal traces of ‘pseudo-code’ or rhetorical negotiations both in writing and in code that demonstrate a variety of attempts to solve ICS through the individual patches or frameworks that led up to the formation of these overall coding changes in 2.0. Consider one of Per Mathison’s early efforts to battle ICS in an Oct 13, 2004 patch prior to the update to 2.0 that offered (in my best estimation) an early attempt to develop the empire_size_base code. ⁹³ He developed a patch that combined ‘empire_size_inc and empire_size_mod, and two server options cityfactor and angrycitizen. The attached patch combined the three first into one government ruleset option unhappy_factor . . . One unhappy starting citizen for each unhappy_factor number of cities you have in total.’⁹⁴ His particular patch for the city.h is a ‘diff’ file that uses ‘-’ and ‘+’ symbols to indicate which lines are being added or subtracted from the original code. Diff files highlight the literal distinction between distinct temporal instantiations of executable code because they indicate the differences between files and the automatic patching of those differences into code.

His specific addition to the city.h code is a patch for the ‘content_citizens()’ function is prefaced by the notational comment, ‘Give base number of content citizens in any city owner by pplayer. We + reduce the number of content citizens for each ruleset value + unhappy_factor number of total cities we have. This is a game mechanic + meant to punish horizontal expansion (infinite city sprawl).’⁹⁵ In the actual code, he has deleted the old basis variable and located the more important step at ‘if (step > 0).’ This function calculates the number and constrains the behavior of happy citizens within the empire. It does that by taking the total number of citizens (which starts out with the name ‘content’ in the code) and subtracting the number of cities divided by the ‘unhappy_factor’ step (unhappy_factor is obviously defined elsewhere by the ruleset). With this addition, we see that if unhappy_factor is set to 0, then this patch will do nothing. Otherwise, unhappy_factor will effectively control how quickly the number of unhappy citizens increases as the number of cities increases. The player gains an extra unhappy citizen for each unhappy_factor number of cities a player has.

Attunement to FreeCiv’s Code

The patch and the diff file testify to FreeCiv’s iterability as a part of code’s condition of possibility. Mathison’s justification for the patch clearly mounts claims (utens) through written expression that precedes the actual code and through figurative and technical expressions within the code that he hopes will persuade other programmers and users of the importance of his patch. However, despite all of these visible elements produced by multiple agents, figurative and expressive significations, and traces of temporal and processual iterability, ontological concealment means that we cannot locate rhetoric in code’s epistemic and visible elements alone. Chun’s passing reference to speculative techné can be more fully fleshed out in the context of FreeCiv by examining two of Heidegger’s terms for situating human agency and perception within the world of concealed Things: ‘world disclosure’ (Erschlossenheit) and ‘attunement’ or ‘mood’ (Stimmung).⁹⁶ Disclosure is the material, practical, and technological background that enables us to form intelligible statements or knowledge about reality as well as engage in practical instrumental actions like coding. Yet, Heidegger claims that humans are not fully responsible for the process of disclosure. What a given FreeCiv coder perceives through words, actions, and the process of coding a videogame already reflects how different material components or affectivities have emerged and cohered within material environments. When a coder changes backgrounds by programming a new videogame instead of FreeCiv, she changes the ways in which she perceive how things will be disclosed to her by other actors within the system. Rickert’s Ambient Rhetoric offers a useful point of clarification. Worldview for Heidegger is not epistemic in the sense of we all have a subjective worldview produced by our cultural or ideological backgrounds. Disclosure through unconcealment in code produces these linguistic frames, but also exceeds them. Echoing similar ontologies such as Karen Barad’s ‘agential realism,’ Rickert argues, ‘There is no ‘my’ way and ‘your’ way of seeing the world, no epistemological windows on a (stable, objective) world ‘out there’ that in turn substantiate cultural relativisms. Rather, world is already implicated, and hence it both generates and participates in who we are.’⁹⁷ Rather, there exists a ‘fundamental entanglement, with the individuation of particular facets being an achieved disclosure.’⁹⁸ In other words, coders never muster a given linguistic worldview (technical or rhetorical) separate from its prior instantiation from cognitive patterns, networks, spaces, and materials conditions. By extension, FreeCiv’s code never makes any persuasive claims separate from its specific modes of comportment within a larger ensemble of material affordances and involvements.

Because our immediate perceptions of code invariably reflect pre-given world disclosures, we cannot fully represent code’s ontological concealment—its speculative techné. In keeping with Heidegger’s thinking, the World (Welt) ultimately withdraws from its relations in the manifest world. By definition, a disclosure is only ever partial because reality never fully unconceals. Thus, it is not recognition, perception, or representation but attunement to the World’s disclosures that ultimately characterizes code’s ontological character. Attunement refers to this unfolding and co-responsive form of the ways we dwell as immersed beings (mit zein) in specific computational, material, and social environments.⁹⁹ It is true that an individual agent does not have to understand all of these factors to engage in rhetorical activity or to code. Nevertheless, learning about these unintentional symbolic and nonsymbolic elements and resonances allows us to understand a more complex and fuller picture of how persuasion emerges from material relations within videogame code. Dwelling (Ethea) indicates the ways in which we live in the attunements that illustrate our specific manner of being-together-in-the-world and move us to particular comportments.

An analogy from complex systems theory offers another useful illustration of ontological concealment and attunement with regard to Mathison’s agency in FreeCiv. Undoubtedly, much in code’s enactment as logos can be explained through a linear, efficient, or mechanical mode of analysis for cause and effect such as the classical example of a billiard ball moving another billiard ball in a specific direction. Yet nonlinear or emergent causality refers to the ways in which code joins a unique network of actors (human and nonhuman) to form an emergent whole whose composition is irreducible to mechanical causality whose whole is greater than the sum of individual parts. By extension, individual rhetorical acts in FreeCiv’s collaborative coding community function more like perturbations within complex ecological systems where Mathison’s agency is established through his individuation within the evolving world of code. In my reading, code’s ability to surprise a coder presupposes this sort of non-linear or unconealing (unfolding) universe. Our bearing and modes of comportment within these wordly systems are given to us by code’s pre-symbolic disclosures. Speculative techné designates precisely this dynamic through which code’s participation in a social and material assemblage retains a potential dynamic to exceed players’ and designers’ intentions. By extension, rhetorical agents can bring forth actions and engage in interactions within the whole network of inter- and intra-acting parts of FreeCiv—worldly disclosures in Heidegger’s sense but the changes that result are determined by the structure of the disturbed system—the condition of possibility for symbolic action and the automatic executability of code alike. In this sense, actors who program the code of FreeCiv are determining without being fully determined in an ongoing process of disclosure and attunement that participates in the unconcealment of FreeCiv’s code but without ever fully revealing it. The activity of programming is therefore not reducible to a single effect from an individual (or collective) instrumental action, but refers instead to patterns that develop out of the dynamic multitude of interacting parts. Mathison or any programmer is responsible—a clear pedagogical point for rhetorica docens—for his actions within this system that he is an agent within; however, at the same time, he is not the sole cause of all emergent effects within this system.¹⁰⁰ Code retains its fundamental ontological concealment.

It is important to add that not all bearings in FreeCiv’s code are even perceived or shaped by human agency. Evidence of non-perceived effects can be seen by asking of FreeCiv’s code the same question that Bogost asks in Alien Phenomenology via Fye’s Deconstructulator: what does code perceive that players and human coders do not? For the object-oriented ontologists, it is not humans alone who are the Lord and shepherd of Being as Heidegger believed. According to Bogost via Harman, all modes and manners of being(s) (humans and nonhuman) have sway in the world. While ontological concealment means that we cannot fully know code’s reality, Bogost nevertheless suggests that we can metaphorically speculate about the way that it perceives the player’s activities. Consider the following lines that establish the city parameters in the city.c code:

bool is_valid_city_coords(const int city_x, const int city_y)
{
int dist = map_vector_to_sq_distance(city_x – CITY_MAP_RADIUS,
city_y – CITY_MAP_RADIUS);
}¹⁰¹

This code scans the player’s city map and, in turn, determines happiness factors with relationship to empire_size_inc and other ruleset options. These lines are responsible for telling the game engine about the state of the game at any one moment. The scan mechanism (checked alongside X/Y axes) looks at the borders and then determines happiness/unhappiness factors. Simply put, the computer perceives a quantitative relationship. The player seeks to take in the map as a qualitative whole for interpretation while the computer checks employs numbers to check at point-by-point intervals. Cities in FreeCiv, for example, are never completely experienced in this fashion by the player.¹⁰² The computer’s perception never entirely unconceals or appears and yet it is nevertheless an actual part of ontological thing-ness of FreeCiv’s code: a present absence.

Perhaps my favorite example of ontological deviousness in FreeCiv’s city.c code lies in the original 1.0 code regarding the production of content, unhappy, and angry citizens. We find a curious notional comment in lines 2386:

\/**************************************************************************
Create content, unhappy and angry citizens.
**************************************************************************/
static void citizen_base_mood(struct city *pcity)
{
struct player *pplayer = city_owner(pcity);
citizens *happy = &pcity->feel[CITIZEN_HAPPY][FEELING_BASE];
citizens *content = &pcity->feel[CITIZEN_CONTENT][FEELING_BASE];
citizens *unhappy = &pcity->feel[CITIZEN_UNHAPPY][FEELING_BASE];
citizens *angry = &pcity->feel[CITIZEN_ANGRY][FEELING_BASE];
citizens size = city_size_get(pcity);
citizens specialists = city_specialists(pcity);
. . .
/* No one is born happy. */
*happy = 0;
}¹⁰³

The phrase, ‘No one is born happy’ carries a double meaning for the citizen_base_mood function. The computer views all avatars in each round in terms of their potential numbers of happy, content, unhappy, or angry citizens—basic calculations for intermediate results that other functions will utilize later. The literal meaning of happy = 0; indicates that the default state of the game means that we have no happy citizens if we only consider city size and ruleset. Happy citizens can only be added in other places in the code, incorporating other factors (such as luxuries). Within this file, citizen_base_mood is only referenced in one other place—a function called city_refresh_from_main_map(). We know, then from this line, that citizen_base_mood runs first and then runs many other functions to add or subtract happy citizens such as citizen_happy_luxury(), citizen_happiness_nationality(), etc. At one level, ‘no one is born happy’ is simply a flippant manner of reinforcing the fact that other features beyond citysize and ruleset determine factors. One might say that citizens are ‘born’ content, unhappy, and angry, because those base numbers are determined by city size and ruleset, but not happiness.

At another level, the omitted conclusion of the phrase—intentional or unintentional—refuses to allow us to ‘end’ our analysis at the literal code itself. The entire quote in common parlance reads, ‘No one is born happy but everyone is born with the ability to create happiness.’ ¹⁰⁴ The quote anthropomorphizes autonomous (human) agency into the compiler. This metaphorical doubling indicates that the machine in non-linear execution (compiling intermediate effects) ‘chooses’ to make citizens happy or not due more (perhaps) to its own perception of the gameset than any intended action by a player. Actual avatars in the game cannot make themselves happy or create their own happiness, but neither can the player ever autonomously assign avatar happiness. It is the entire rhetorical ensemble—source code, compilation, execution, patches, play—that eventually affects the intermediate code results that make avatars happy. Happiness is not an emotional, subjective state randomly generated, but an absolutely determining and deterministic condition set in relationship to quantitative yet concealed and unfolding factors. The lines also unconsciously satirize the player’s own futile existential condition with respect to ICS. Despite attempts to eliminate ICS through collective acts of coding, the FreeCiv Wikia laments that even 2.0 and 2.2 updates were unable to ultimately solve the ICS problem. It is actually a core part of classical rhetoric in Miller’s sense—decorum and consensus—within the player and coder community to agree not to play ICS that actually stemmed the flow. By dubbing ICS a ‘serious breach of playing etiquette,’ FreeCiv’s code was finally able to produce happy ‘players’ alongside appropriately happy citizens.¹⁰⁵ This recourse to social and discursive solutions—the historic domain of rhetorical persuasion—offers further confirmation of Chun’s most significance point: code never fully determines its results.

Conclusion

While my reading just scratches the surface of FreeCiv, the significance of ontological concealment—Barnett’s ‘letting be’ of rhetoric—is clear. We should not allow our desire to name the tools of code—figural, technical, expressive, literal, or epistemic—to be accompanied by an impoverished ontological framework. Even Mathison’s strategic patch or Mike Jing’s essay are only parts of an unfolding series of patterns (disclosures) that would eventually result in an insufficient overhaul (comportment) of the entire game’s mechanics in version 2.0. Thus, regardless of the fact that there were indeed various procedural rhetorical aims and goals in eradicating ICS, ontological concealment means that no one agent—human or nonhuman—fully encounters the reality of the game in code, even when its iterability seems to be most obvious and visible. These symptoms that I have identified as flux and updates and changes are but individuated traces of a concealed yet dynamic whole—the present/absent thing-ness of the code. With regard to docens, the coder never fully attains enlightenment or mastery and can never fully reveal the tools.

Ontological concealment recognizes programmers, code, and players as agents in the persuasiveness of code’s effects and affects. Coders try to eradicate ICS through code, and, in the end, it is a very social and epistemic form of rhetorical decorum that carries the day—but a decorum that is not purely cognitive or social and is co-produced by players’ involvements with the unfolding nature of code through a never-ending-series of iterable feedback loops. The lesson is clear: all are agents in persuasion; all code decisions are embodied and enacted through temporal and material fashion. Code as fixed object—technical or expressive—is only a moment of provisional cohesion that is enacted and re-enacted across its temporal and material iterability.

Even if software studies does not desire in the future to invoke the specific term ‘rhetoric,’ it is my belief that researchers’ accounts of code can nevertheless benefit from considering rhetorical ontology’s negotiation of the complex, emergent, and ecological interplay between critical revelation (docens) and expressive concealment (utens). On the one hand, realizing that rhetoric historically represents this dissimulating ‘other’ that (computer) science or Platonic code-as-logos seeks to immunize itself from in revelation is productive for software studies in a number of ways. As ‘other’ to Platonic truth, rhetoric best signifies the critical need to theorize the actual yet concealed realm of the social and contingent behind any technical, scientific, or philosophical description of reality or act of coding. Rhetoric’s status as marginalized, vapory, speculative, epistemic, figurative, or ontological within a given account of code indicates whether this account retains or rejects the Platonic inheritance of good and bad rhetorics of code. If an account of code remains within a Platonic inheritance, then its theories of meaning and expression will invariably tend to reinscribe a willful human agent along the lines of Chun’s neoliberal enlightenment philosopher who is immune from rhetorical contamination.

On the other hand, rhetorical theory’s constant attention to the interplay between analysis (docens) and production (utens) pushes software studies to more accurately define productive agency with respect to revealing the reality of code. In my opinion, rhetorical ontology demonstrates that it makes little sense for researchers to shift the locus of meaning in computational media from the screen to the code if researchers retain an unproductive or ontologically impoverished vision of reality, perception, and agency. Rhetorical theory also highlights the need to constantly account for the multiple levels of rhetorical expression within code that are irreducible to epistemic revelation and critique, but that nevertheless serve as a condition of possibility for code’s instruction and execution through the prior, dynamic, and ongoing affectability of code and coders. Code’s rhetoric never fully unconceals in execution and understanding the interplay of concealment and revelation are what ultimately allow for accurate tracing of utens within complex social and technological ecologies such as FreeCiv.

Under ontological concealment, utens for software studies is not defined in the end by willful mastery or a postmodern fragmentation of the knowing subject. Rather, utens maintains each agent as an autonomous (but individuated) and self-organizing being with respect to the worldly systems through which they emerge. Code in FreeCiv is indeed layered but not like an orderly recipe for critique as code never fully unconceals its Being. We (programmers and rhetors) are in the world exactly as much as code is. This realization is what lesson ontological concealment has for the docens/utens problem, wherein potential cynicism and endless regress give way to Chun’s speculative wonder and play at code’s never-ending sophistical deviousness. It is a starting place—and not a final resting stop—toward thinking about our capacities for producing more ethical forms of human concealment in code.¹⁰⁶

Acknowledgements

I want to express my sincere gratitude to both of my anonymous reviewers. This article is lengthy, and both individuals offered by far some of the most thoughtful and detailed feedback work that I have ever received over the course of my scholarly career. Their advice was invaluable in terms of helping me to refine my thinking in this final article. I also want to thank my younger brother and expert coder Nathan Holmes, who provided feedback on an early draft of my effort to read FreeCiv’s code.

References

Aristotle. On Rhetoric: A Theory of Civic Discourse. Translated by G.A. Kennedy. 2nd ed. New York: Oxford UP, 2007.
Barnett, Richard Scot. Arts of Concealment. Unpublished dissertation. University of Wisconsin- Madison, 2010.
Bogost, Ian. Alien Phenomenology, Or What It’s Like to Be a Thing. Minneapolis, Minn.: U of Minn P, 2012.
Bolter, Jay David and Diane Gromala. Windows and Mirrors: Interaction Design, Digital Art and the Myth of Transparency. Cambridge, Mass: MIT, 2005.
Brock, Kevin. ‘One Hundred Thousand Billion Processes: Oulipian Computation and the Composition of Digital Cybertexts.’ In Technoculture 2 (2012) : n.p.
Brooke, Collin Gifford. Lingua Fracta: Toward a Rhetoric of New Media. Philadelphia, N.J.: Hampton, 2009.
Burke, Kenneth. A Rhetoric of Motives. Berkeley: U of California P, 1969.
Cahn, Michael. ‘The Rhetoric of Rhetoric: Six Tropes of Disciplinary Self-Constitution.’ In The Recovery of Rhetoric: Persuasive Discourse and Disciplinarity in the Human Science, edited by R.H. Roberts and J. M. M. Good, 61-84. Charlottesville: U of Virginia P, 1993.
Carnegie, Teena A.M. ‘The Interface as Exordium: The Rhetoric of Interactivity.’ Computers and Composition 26, no. 3 (2009) : 164-173.
Cicero, Marcus Tullius. De Oratore. Translated by H. Rackham. 2 vols. Loeb Classical Library. Cambridge, Mass.: Harvard UP, 1942.
Cherwitz, Richard A. and TJ Darwin. ‘Why the ‘Epistemic’ in Epistemic Rhetoric? The Paradox of Rhetoric as Performance.’ Text and Performance Quarterly. 15 (1995) : 189-205.
Chun, Wendy. Programmed Visions. Cambridge, Mass: MIT UP, 2012.
‘Coding Style.’ FreeCiv Wikia. Last accessed in April 2014, http://FreeCiv.wikia.com/wiki/Coding_Style
Cole, Thomas. The Origins of Rhetoric in Ancient Greece. Baltimore MD: Johns Hopkins UP, 1991.
Consigny, Scott. ‘Rhetorical Concealment.’ Paper read at Theory of Rhetoric: An Interdisciplinary Conference. Minneapolis, Minn. 1979.
Cooper, Marilyn R. ‘Rhetorical Agency as Emergent and Enacted,’ College Composition and Communication 62, no. 3 (2011) : 420-449.
Davis, Diane. Inessential Solidarity. Pittsburg, Penn: Pittsburg UP, 2012.
‘Editing Rulesets.’ FreeCiv Wikia. Last accessed Apr. 2014. http://FreeCiv.wikia.com/wiki/Editing_rulesets
FreeCiv 1.0. FreeCiv Wikia. Last accessed Apr. 2014. http://FreeCiv.wikia.com/wiki/Editing_rulesets
— 2.0. FreeCiv Wikia. Last accessed Apr. 2014.
Galloway, Alexander R. Protocol: How Control Exists After Decentralization. Cambridge, Mass: MIT, 2006.
—. ‘Language Wants to Be Overlooked: Software and Ideology.’ Journal of Visual Culture 5, no. 3 (2006): 315-331.
Garsten, Bryan. Saving Persuasion: A Defense of Rhetoric and Judgement. Cambridge, Mass.: Harvard UP, 2006.
Harman, Graham. ‘On Vicarious Causation.’ Collapse: Philosophical Research and Development. 2 (2007) : 187–221.
Heidegger, Martin. ‘The Thing.’ In Poetry, Language, Thought, 161-
184. New York: Harper, 2013.
‘Infinite City Sprawl,’ Sid Meyer’s Alpha Centauri. Last accessed Apr. 2014. http://sidmeiersalphacentauri.wikia.com/wiki/ Sid_Meier’s_Alpha_Centauri/Getting_Starte
Jing, Mike. ‘FreeCiv Without City Smallpox.’ FreeCiv Wikia, 2003. http://FreeCiv.wikia.com/wiki/FreeCiv_without_city_smallpox
Kirschenbaum, Matthew. Mechanisms: New Media and the Forensic Imagination. Cambridge, Mass: MIT, 2012.
Lunenfeld, Peter. Snap to Grid. Cambridge, Mass: MIT, 2001.
Manovich, Lev. The Language of New Media. Cambridge, Mass: MIT, 2007.
Mathison, Per. ‘Cleanup of Empire Size and Unhappiness.’ FreeCiv Development, Oct. 13, 2004. http://permalink.gmane.org/gmane.games.FreeCiv.devel/47205
Miller, Carolyn R. ‘Should We Name the Tools?’ In The Public Work of Rhetoric: Citizen-Scholars and Civic Engagement, edited by John M. Ackerman and David L. Coogan, 19-38. Columbia, SC: University of South Carolina Press, 2010. Plato. The Collected Dialogues. Edited by E. Hamilton and H. Cairns. Princeton, N.J.: Princeton UP, 1961.
‘Program or Be Programmed.’ Computers and Writing Conference. Raleigh, N.C. 2012. http://enculturation.gmu.edu/computational-literacy
Quintilian. Institutio Oratoria. Translated by H.E. Butler. 4 vols. Loeb Classical Library. Cambridge, Mass.: Harvard UP, 1920.
‘Reading Games: Composition, Literacy and Video Gaming.’ Computers and
Composition Online: Special Issue. 13 (2009).
‘Remember.’ FreeCiv Wikia. Last accessed April 2013. http://FreeCiv.wikia.com/wiki/Remember
Rickert, Thomas. Ambient Rhetoric. Pittsburg, Penn: Pittsburg UP, 2013.
Sample, Mark. ‘Criminal Code,’ Digital Humanities Quarterly 7, no. 1 (2013) : n.p.
Thacker, Eugene. ‘Foreward.’ In Alexander R. Galloway’s Protocol, iii-xvi. Cambridge, Mass: MIT, 2006.
Worsham, Lynn. ‘The Question Concerning Invention.’ Pre/Text 8 (1987) : 197-244.
Unold, Peter, Claus Leth Gregersen and Allan Ove Kjeldbjerg. FreeCiv. GNU General Public License. November 1995.

 

Notes