Files in this item

FilesDescriptionFormat

application/pdf

application/pdfMichael_Black.pdf (2MB)
(no description provided)PDF

Description

Title:Transparent cultures: Imagined users and the politics of software design (1975-2012)
Author(s):Black, Michael
Director of Research:Markley, Robert
Doctoral Committee Chair(s):Markley, Robert
Doctoral Committee Member(s):Underwood, Ted; Littlefield, Melissa M.; Schaffner, Spencer W.; Newcomb, John T.
Department / Program:English
Discipline:English
Degree Granting Institution:University of Illinois at Urbana-Champaign
Degree:Ph.D.
Genre:Dissertation
Subject(s):Software Studies
Digital Humanities
History of Computing
English
Abstract:The rapid pace of software’s development poses serious challenges for any cultural history of computing. While digital media studies often sidestep historicism, this project asserts that computing’s messy, and often hidden, history can be studied using digital tools built to adapt text-mining strategies to the textuality of source code. My project examines the emergence of personal computing, a platform underlying much of digital media studies but that itself has received little attention outside of corporate histories. Using an archive of technical papers, professional journals, popular magazines, and science fiction, I trace the origin of design strategies that led to a largely instrumentalist view of personal computing and elevated “transparent design” to a privileged status. I then apply text-mining tools that I built with this historical context in mind to study source code critically, including those features of applications hidden by transparent design strategies. This project’s first three chapters examine how and why strategies of information hiding shaped consumer software design from the 1980s on. In Chapter 1, I analyze technical literature from the 1970s and 80s to show how cognitive psychologists and computer engineers developed an ideal of transparency that discouraged users from accessing information structures underlying personal computers. Prior to the early 1980s, software designers assumed that users were at least semi-literature in the technical details of computer systems. In response to the expanding popular interest in personal computing, engineers abandoned this assumption and began to design hardware and software for users with little or no understanding of computer systems. Successful software design became defined by the invisibility of computation. Users were made to feel that they were directly manipulating their data. Intimidating command prompts were hidden, and the complex operations performed through them automated behind simpler, visual metaphors like the desktop. In contrast to its political connotations, “transparency” in the context of design represents a strategy of withholding technical information. As I argue, transparency’s paradoxical promise stems from the instrumentalist belief that problems of access should be addressed through an artificial increase in technological literacy. Chapter 2 argues that the commercialization of transparent design established a computational horizon. In analyzing popular computing magazines published during the early 1980s, I show how Apple positioned the Macintosh in opposition to the rationalism of IBM, promising that the future of computing would be one in which users would be empowered by machines that “just worked.” Apple established transparency as the teleological purpose of technological development: computational power must remain invisible even as its representations become increasingly visual. Yet Steve Jobs was not the only one to imagine such a future. The cyberpunk writings of William Gibson and Bruce Sterling respond to the cultural constraints of transparent design. In cyberpunk’s dystopias, transparency reifies technocratic power, granting only a small number of corporate actors control over computation. While critics have argued that Gibson and Sterling strive to make information systems visible, I argue that their hackers are constrained by transparency, regularly encountering limits to their own computational agency in an ultra-transparent cyberspace. Cyberpunk thus offers a vision of a future where computers “just work,” as Apple promised, but often at cross-purposes with their users. Even if the veil of transparency were lifted, modern software is constructed according to principles that resist critical readings of source code. Chapter 3 asserts a need for methodologies in software studies that can account for the scale and scope of contemporary software. Whereas early software was written from beginning to end much like a script or an essay describing a process, more recent languages break software into an assemblage of encapsulated components. As I argue, fears of “spaghetti code”—software with routines so entangled that delineating specific processes is impossible—imagine developers succumbing to the sort of the mania described in Robert Coover’s The Universal Baseball Association. Object-oriented programming, by contrast, stresses modularity and encourages programmers to write components with singular functions that can be incorporated into software by their peers without needing to be managed directly. In this manner, structured programming’s guiding principles produce a hierarchy both within software and through acts of collaborative programming. This “freedom from” overwhelming complexity, however, comes at the cost of producing highly constrained network perspectives that resemble those found in Margaret Atwood’s The Handmaid’s Tale. Accounting for this structure, I conclude, requires something more than the close reading of code’s aesthetics advocated by methodologies like Critical Code Studies. The final two chapters are case studies that build text analysis tools to map software’s sprawling assemblages and rapid evolution, respectively. Chapter 4 takes as its object the open source software movement, studying both its various manifestos and the source code for software produced by its members. Examining the movement’s foundational texts, I argue that open source principles reflect a strong opposition to transparent design. Its founders assert that writing software is a form of expression and refuse to distinguish between sociocultural and technical concerns. In theory, open source software should reflect these principles; however, by applying topic modeling and social network analysis tools to source code for the Linux operating system, I demonstrate that it exhibits a form of structural obfuscation similar to that in commercial software. This study suggests not only that structured programming relies on the same principles and strategies as proprietary design but also that transparency’s obfuscation of computation need not restrict the user’s agency. These restrictions are a deliberate choice by designers rather than an inherent feature of software as a medium. Despite the system’s structural obfuscation, Linux’s designers account for the political implications of structured programming by allowing users to bypass transparency entirely, leaving core mechanisms open to configuration in ways that Apple and Microsoft forbid. Chapter 5 takes as its object of study the source code to sixty versions of Mozilla Firefox, tracing the program’s ancestry to Netscape’s decision to release the source code to its Communicator browser suite in 1998. Including source code in our understanding of software’s materiality exposes a complex bibliographic history that quickly becomes too large to study through traditional methods of close reading. In order to address the textual duplication present in a corpus of successive versions of an application, I build topic modeling software tailored to source code’s iterative inscription. In expanding software’s materiality to include its source code, this case study shows that software’s internal structures are subject to constant evolution and that transparent design often leads to large-scale changes in software that go unnoticed by users as long as the interface remains relatively unchanged. While digital tools can help us explore large bodies of cultural data, a critical theory of software construction is essential to help make sense of it.
Issue Date:2014-05-30
URI:http://hdl.handle.net/2142/49703
Rights Information:Copyright 2014 Michael L. Black
Date Available in IDEALS:2014-05-30
2016-09-22
Date Deposited:2014-05


This item appears in the following Collection(s)

Item Statistics