/ / Critical Code Studies

Abstracts

Ξ July 15th, 2010 | → | ∇ test |

128-bit Thurn und Taxis: IPv6 and the Internet of Haecceities
Benjamin H. Bratton

What is the quality of the address? What is the nature of that thing which can be addressed, the haecceities? In Thomas Pynchon’s The Crying of Lot 49 addressing systems signified an essence of political authority and the interplay of the transparent and the undisclosed. That characterization is true.

As is often described in the literature on ubiquitous computing, IPv6 allocates a theoretical limit of 5 x 1023 addresses per human. This begs the question of whether over the course of a natural life one comes into contact with that many potentially addressable instances? What is the ultimate granularity that might exhaust this supply? Addressing every letter in every book? Every blood cell? Every neural network? As part of some planetary computational apparatus, what would it mean to address and account for temporal constructs as they emerge? 

The logic of a truly universal addressing resolver would include not only “things” we process and communicate as discreet information, things much bigger than us and much smaller than ourselves in scale, things much slower and much faster, would also resolve “us” as points within their possible communicative fields. Whatever characteristics that compose our recombinant selves –proto-events, words, gestures, preferences, perhaps even neuronal and chemical patterns, genetic figures and expressive dispositions– are potentially part of a process of tagging and addressing worldly singularities.

Beyond the “spime,”there is a politics of the network address that may come to redefine other political geographies and jurisdictions in its image. Combining aspects drawn from critical sources (such as Bruno Latour’s parliament of things, some insights associated with Object-Oriented Philosophy, as well as Martin Heidegger’s definition of “the thing” as a relational field of forces and origins) with a consideration of the real and implied digital haecceities (a functionally addressable entity within a mature internet of things), this paper will outline how the logics of the digital address field change our understanding of the quality of objects, and how problematics in the social philosophy of objects can frame our ongoing design of that addressing system as global infrastructure.

Undefined Intimacy with the Machine: Standard C and “Undefined Behavior”
Evan Buswell

In the various standards documents, there are numerous aspects of the programming language C that are designated to result in “undefined behavior,” “unspecified behavior,” or “implementation-defined behavior.” This has been known to make many programmers nervous. But although the semantics of these constructions are ambiguous, when one has an architecture and compiler in mind, or a set of architectures and compilers, this ambiguity sometimes results in a closeness between the code and the machine, a deep connection between general language constructs and the specific shuttling of electrons. Whereas defined behavior replaces the machine with its own normalizing abstraction, undefined behavior abstracts while allowing the idiosyncrasies of the machine to be seen. What we have here are two different kinds of abstraction: abstraction by specification, definition, and replacement; and abstraction by ambiguity. If we think of C as a language for the exact specification of algorithms—and this aspect of C is precisely what makes it a codic language—then these areas of undefined behavior are problematic. But if we view C as a language for human-machine communication, then these areas of undefined, unspecified, and implementation-defined behavior are where the language blossoms and the abstractions give way to an intimacy with the machine.

When Relational Isn’t Enough: Software Architectures for Scholarly Production
Craig Dietrich

Relational databases are the backbone of many humanities projects that engage with and produce scholarship. The relational model—storing information in key-based table structures—is a literacy in three dimensions, providing authors an opportunity to create webs of knowledge that drive digital production. Yet some properties of relational databases that have helped make them popular—they are fast and comfortably similar across table schemas—are a result of normalization derived from their origins assisting bank transactions and military interpretations. When faced with scholarly nuances that have trouble conforming to relational model rigidity, technologists working in the humanities circumvent normalization with creative and sometimes bizarre schemas and data structures.

Innovative software architectures emerge when traditional relational models can’t capture a project’s nuances. Incorporating semantic web principles, many humanities projects store data along with its meaning, merge knowledge ontologies, and facilitate sharing via open networks. This talk will discuss scholarly software challenges and innovative solutions by traversing four case-studies of systems in development—with specific code from each. Featuring a range of relational and semantic approaches: the Mukurtu Archive content manager based on Aboriginal cultural protocols; Metaserver, an art archive registry produced by UMaine’s Still Water lab; Scalar, a media studies publishing platform by USC’s Vectors Journal; and Magic, a system for annotating code with cultural material and vice verse.

Comments on Comments in Code
Jeremy Douglass
Researcher, UCSD

Where in source code do we locate the “extra-functional significance” that Critical Code Studies calls us to critique? One starting point is in code comments. In most programming languages, comments are simple marks that set aside text for humans to read but computers to ignore. The act of “commenting” and “uncommenting” circulates this text into and out of the code per se, which is to say into and out of the purview of the compiler / interpreter. Like footnotes or endnotes, code comments are paratexts — continuous with and yet set apart from the source. Where they serve as actual *commentaries*, these paratexts enabling programmers to signal intentions, record histories, and render aesthetic judgements: comments enable the vital processes of software development culture.

Code comments locate the affective in code, attaching moments of rage or humor or joy attaches to points of functionality. They also assert significance, including statements of copyright, expressions of suspicion and doubt, or descriptions of future plans and aspirations. Comments are part of a vernacular, with their own folk traditions and lore. They are also the subject of aesthetic debates within software engineering cultures, whether simple preferences for minimalist / maximalist commentary or full philosophies and methodologies such as “literate programming” and “self-documenting code.” Comments serve a rhetorical function as a figure for code in discourse outside code-literate culture. In public political and legal debates — from investigative reporting into “Climategate” code to the court cases over the legal status of Linux source in “SCO v. IBM” — comments serve as evidence, not just as a shorthand for code *functionality*, but as the essence of code *intentionality*.

Considering comments complicates our conception of what code is, and how we can critique it.

The legend of Mariner I
For an analysis of the impossible linearization of code
Federica Frabetti
(Oxford Brookes University, UK)

In this paper I propose a cultural analysis as well as a critical reading of a famous piece of Fortran code, which erroneously has been held responsible for the failed launch of Mariner I, the first American space probe, in 1962. After explaining how numerous ‘urban myths’ have been constructed around this apparently innocuous piece of code – which in fact, when executed, leads to an infinite loop – I turn to a deeper investigation of its functioning. My aim is to show how, more generally, some unpredictable consequences of software-based technologies can be viewed as the result of what I propose to call the ‘impossible linearization of code’.

I focus on the way in which a Fortran compiler works and I take into examination some of the political and cultural assumptions implicit in the process of compilation. I show in what ways the misguided introduction of a dot (‘.’) rather than a comma (‘,’) into the source program - a human error on the part of the programmer – escapes the compiler and how, ultimately, the apparent perfection of this line of code leads to uncontrollable consequences and potentially to disaster. Thus, I advance the proposal of understanding code as a process of unstable linearization. Drawing on the work of theorists such as Bernards Stielger and Jacques Derrida, but also on classics of the theory of programming languages, I show how the functioning of code is based on fundamental assumptions about writing, calculability and instrumentality that characterize the Western thought on technology – and how, nevertheless, code unavoidably exceeds and escapes such assumptions. Ultimately, I argue that such a problematizing reading of code can be beneficial in the context of Critical Code Studies, since it enhances our capacity to engage with software-based technologies deeply on both the cultural and the political level.

Academic Discourse and Text Generators: Manifestos, Servers, Languages, and Code
Elizabeth Losh
University of California, Irvine

This paper looks at two recent text generators that are intended to raise questions about the style and substance of academic writing: Andrew Bulhak’s “Postmodern Essay Generator” and Ian Bogost’s “Latour Litanizer.”

Bulhak created his generator in the wake of the Sokal hoax to mock the pretentious vocabularies of aspiring intellectuals who might hope to publish what he considered to be their relativistic and impenetrable nonsense in peer-reviewed scholarly journals in the humanities. The generator creates sentences like this each time the page is refreshed: “If one examines subtextual deconstructivism, one is faced with a choice: either accept dialectic materialism or conclude that the collective is responsible for class divisions, but only if sexuality is interchangeable with consciousness.” Bulhak used the Dada Engine to create the verbiage in the essays his program generated. The actual program was written in what he called “inelegant” pb code that used protocol buffers – a platform-neutral, language-neutral, extensible way of serializing structured data – and recursive transition networks (or RTNs) to create a diagrammable grammar that Bulhak also retasked in a program for automatically writing adolescent poetry dominated by “i” statements.

In contrast, Bogost devised a much simpler javascript program that uses Wikipedia’s random page API to generate lists of things and to provide brief poetic homages to the writing style of philosopher of science Bruno Latour, which frequently includes lists of seemingly disconnected objects. Bogost’s program, which ends with the command to “litanize,” has also been deployed in his larger critique of writing in the humanities, which is not only bad in his mind because it is obfuscatory but also because it is disconnected from the catalogues of things in everyday experience that he holds dear. A sample list created by the Latour Litanizer reads as follows: “Energy Tax Act, Linux Users of Victoria, Burton House, Fault line, NCAA Women’s Division II Basketball Championship, USS Apache, Quinquagesima, Dąbrowa, Wieliczka County, Karel Rychlík.”

It could be argued that both Bulhak and Bogost use their generators somewhat disingenuously. Bulhak closely engages with the linguistic features of the poststructuralist vocabulary he appropriates and struggles to create grammatical sense by tweaking his program to accommodate such complex, multisyllabic words. Bogost incorporates Latourian litanies into his own diatribes against the digital humanities and the humanities more generally, but each item is carefully chosen in accord with his own writerly ear rather than machine-generated by his online gadget with its procedural poetics of chance.

Studying Software by Porting and Reimplementation: A BASIC Case
Nick Montfort, Patsy Baudoin, John Bell, Ian Bogost, Jeremy Douglass, Mary Flanagan, Mark Marino, Michael Mateas, Casey Reas, Warren Sack, Mark Sample, and Noah Vawter

We present one type of analysis of a very short and very interesting program that runs on the Commodore 64, a one-line BASIC program that generates maze patterns by repeatedly randomly outputting a character representing one of two diagonal lines:

10 PRINT CHR$(205.5 + RND(1)); : GOTO 10

This program is a gateway to explaining important concepts in computation, creative and recreational computing, programming languages in general and BASIC particularly, home computing, and the relationship of computing to text, typography, and visual art. It uses randomness and creates a two-dimensional pattern from a repeating, one-dimensional process. It employs character graphics, elements meant to be fitted together like a mosaic which were implemented on top of an essentially typographical system. While the program is compelling, it does not easily fit into any standard category (”video game,” “productivity software,” “educational exercise”) that we know of today.

As part of a larger study, we have approached this program by reimplementing it in several different languages on several different platforms, including Commodore 64 assembly language, Applesoft BASIC, JavaScript, Perl, Python, Processing, and the weird programming language Path, which uses “\” and “/” characters that are similar to the ones in the original program’s output. By attempting to recreate this program, we discovered aspects of the Commodore 64 platform and the BASIC programming language that are important to the program’s effect.

{untitled on Domain-Specific Languages}
Marisa Plumb

The ability of code to expressively represent its problem-domain is not always its first priority.
However, for the problem-domain of my own art practice - narrative - I have found that the expressive power of a programming language is directly related to its utility and its creative role in molding narrative landscapes. This paper asks questions about the role of expressive code in creative code projects, and takes on two tracks of investigation: 1) it examines the programming tools that are currently used for narrative design (and who uses them), and 2) it proposes the potential benefit of using a a Domain-specific language (DSL) to optimize an author’s relationship to her code-base. On the whole, a desire to represent narrative spaces with code has driven my interest in programmatic approaches to narrative design, with a bias towards non-linear, imaginary narratives.

As such, this paper assumes a broad problem-domain (nonlinear narrative), and seeks optimal solutions for representing narrative with accessible code.

Knock’s Memories: Creating an Emotional Story Space with Inform 7
Aaron Reed
University of California Santa Cruz

In this paper I construct a system for simulating a character’s emotional development using literate Inform 7 source code. Inform 7 is today the preeminent design system for interactive fiction (IF). While prior versions of Inform were “a computer programmer’s tool which aimed to be welcoming to creative writers,” Inform 7 “aspire[s] to be the other way around”: a tool for making interactive stories designed first and foremost for writers, not coders. Inform 7 uses a natural language syntax that lets authors create story worlds with straightforward English sentences, as simple as “Tom is a person” or as complex as “Instead of attacking Tom when something lethal is held, now every nearby watchdog owned by Tom hates the player.” For my 2010 IF “Sand-dancer,” a short interactive story about a surreal night in the life Nakaibito “Knock” Galvano, an eighteen-year-old with a pregnant girlfriend and a dead-end job, I created Inform 7 code that simulates Knock’s backstory and emotional growth. As the player explores, memories of Knock’s troubles keep bubbling to the surface of his mind. Knock can relive his memories with commands like BROOD ABOUT MY CRAPPY JOB, and ultimately trade them for useful life skills with a series of mysterious spirit animals. In the paper I create this system in Inform 7 code and commentary which reveals the uniquely expressive power of the language for simultaneously building constructs in both story and code.

Briefing on Transborder Immigrant Tool Source Code and Persecution of Professor Ricardo Dominguez
Brett Stalbaum
University of California, San Diego

I will be presenting the source code for the Transborder Immigrant Tool. I will show how the facts of the source code itself have not been part of the public discussion about the TBTool, paying particular attention to an exchange with U.S. Congressman Duncan Hunter. In the process EDT/B.A.N.G lab will perform a gesture toward better critical understanding of the code. The presentation will also focus on the legal plight Professor Ricardo Dominguez and the potential connections between his persecution at the hands of UC /UCSD Administration and the TBTool. Also, I will discuss my formal statement to the UCSD Police on July 21st 2010.

Techne-Zen and the Codes of Interface Design
John Williams
Yale University

This paper argues that–contrary to visions of computer code as a culture-less series of absolute and ideologically empty “signals”–a great deal of the basic, “hidden” language running our digital interfaces today emerged within an ideological and cultural construct with a genealogy reaching back to the first moments of cybernetic computationalism. Specifically, I show how the prestige of CSS (”Cascading Style Sheets”) as the design code of choice for the architects of Web 2.0 (particularly in the wildly popular www.csszengarden.com and its accompanying design volume by Dave Shea and Molly E. Holzschlag) relies on the discursive influence of a “cybernetic zen” tradition with its roots in postwar comparativism, including writers like FSC Northrop (in The Meeting of East and West, 1946), Alan Watts (in The Way of Zen, 1958), and Robert Pirsig (Zen and the Art of Motorcycle Maintenance, 1974). The characterization of HTML code as allowing only “rigidly enforced grids that impede the design process” in contrast to the “spontaneous and fluid” powers of the more “Zen” CSS is only the latest version of a post-industrial, orientalist discourse that brings together notions of Eastern mysticism and Western “machines of loving grace.” It is not enough, in other words, to understand that the real heir to Ezra Pound’s modernist orientalism (with its fascistic control of the aesthetic) is the contemporary hardware guru, Steve Jobs. One must also see that the coded, internal structures of our contemporary “Buddha Machines” are inscribed with highly cultural assumptions as well.