Lists and computation

The logic of the list is integral to the world of computing in data structures such as arrays, queues, stacks, and databases, as Vismann (2008), Manovich (2001), and Adam (2008) all highlight. Adam defines ‘List’ in computing as “a data structure that is an ordered group of entities” (2008, p. 174). This structure can be either static or

38 _{Quoted in Benjamin (2002, p. 456).}

dynamic. The former allows only observation and enumeration of elements, the latter allows for manipulation – the insertion, replacement, or deletion of elements. The programming language Lisp (short for List Processor) is the second oldest high-level computing language still in use and is an instructive example in this regard. The constitutive data type of Lisp is, of course, the list, out of which almost all other entities are constructed.40 Echoing Vismann’s description of algorithmic file-notes, Adam points out a double function of lists in Lisp that both program and store data: a list is sent first as a command, the latter is then processed via the list form, after which the data sent and processed stands as a listed record of what has occurred (Adam 2008, p. 177).

Lisp accommodates the mixing of data types (a data type is any type of thing) within the same list. In Lisp, “a variable can hold values of any type and the values carry type information that can be used to check types at runtime” (Siebel 2005, p. 265). That is, you may enumerate within the same list trees, cars, a cat, and

bandages without declaring them to be any single type: (7 TREES 4 CARS 1 CAT 2 BANDAGES)

Lisp does not require a programmer to declare data types in advance according to any guiding principle in order for them to be processed. This runs contra to

programming languages such as C++ and Java. The latter require at the outset a declaration regarding what type of object each variable can hold (and if an object does not match the value assigned it cannot be processed). Because they do not require a human programmer to establish their criteria, lists in Lisp are ‘self-typing’ and thereby inherently more flexible.

40 _{See Derek Robinson, “Function,” in Software Studies, p. 104. While this is true for the original Lisp} language designed by John McCarthy, it is important to note that contemporary iterations, such as ‘Common Lisp,’ incorporate other data types such as vectors and hash tables.

Lisp arises from an alternate a priori than most conventional programming languages. Solomon (2013) shows that Lisp was designed around the principles of Alonzo Church’s Lambda calculus rather than those of Alan Turing’s famous machine (itself based on Charles Babbage’s ‘Difference Engine’). Turing’s Machine and

Babbage’s engine rest on an IF/THEN logic of conditional branching, which is “the construct within a computer program that allows it to alter its flow of instructions based on the result of some other calculation” (Solomon 2013). Conditional branching is described by Kittler in this way: “IF a preprogrammed condition is missing, data processing continues according to the conventions of numbered commands, but IF somewhere an intermediate result fulfills the condition, THEN the program itself determines successive commands, that is, its future” (Kittler 1999, p. 258). In contrast, the Lambda calculus “is based purely on the ability to define functions (subroutines) and for these functions to be able to call each other in an arbitrarily nested or recursive way” (Solomon 2013). Solomon, a computer

programmer, argues that both the Turing machine and the Lambda calculus are equally powerful though they implement conditional branching in different ways. Lisp, using Lambda calculus principles, implements recursively callable functions using a structure called a functional call stack. “Using this structure, the computer stores the state of the current function being evaluated, and if that function calls another function, it will “push” everything down and repeat, so that when the latter function returns, it will “pop” off the top and return back to the prior function” (Solomon 2013). A functional call stack is a flexible, temporally operational list of functions.41 _{The list form provides the required flexibility for the push-pop processes}

of recursively callable functions; it provides the ‘nest’ within which functions can call one another. Rather than a series of function checks and processes set out in

advance by a programmer (IF x occurs THEN y follows; IF x does not occur THEN z,

etc.), functions in Lisp recursively call each other and move up and down the list as required. The flexibility inherent in the list form ensures this freedom of movement.

Furthermore, Adam shows, lists provide a structure that allows Lisp to process symbols rather than simply numbers. According to Lisp creator John

McCarthy, developing a programming language capable of moving beyond ‘number crunching’ and toward reasoning about the world would involve

representing information about the world by sentences in a suitable formal language and a reasoning program that would decide what to do by making logical inferences. Representing sentences by list structure seemed appropriate—it still is—and a list processing language also seemed appropriate for programming the operations involved in deduction—it still is (McCarthy 1996).

Adam (2008) suggests that the list has proven attractive to AI researchers. Lists provide an elegant data structure, not limited by pre-existing abilities, that can both absorb and potentially reason through (rather than simply process), a significant amount of data. As a “programmable programming language,” Lisp very easily absorbs paradigm shifts in programming and will likely continue to do so (Siebel 2005). Thus because its constitutive form is adaptable and can create its own processes, Lisp has survived epistemic shifts in programming better than other languages.

This brief overview of Lisp is meant to show one example in which the list is formally operative in the digital realm. Others can be found, such as ArrayLists in Java or linked lists in C (similarly open-ended data structures). ‘List’ was one of the thirteen original HTML tags designed by Tim Berners-Lee, and lists have always been a major component of the Graphic User Interface (Guillory 2004). Early programmers will no doubt recall ‘program listing’ printouts that stored pages upon pages of line-

by-line code on fan-fold paper.42 _{Algorithms, essential operators in digital}

computation, are finite lists of instructions that enable the calculation of functions. An algorithm without a database to operate on is useless, as is a database without an algorithm to extract and structure its data. “The possibility of abstracting useful knowledge from the end user of a website, for example, is dependent upon the extent to which data is structured” (Fuller and Goffey in Parikka and Sampson 2009). Lists give form to such protocols, and in its algorithmic capacities the list discloses itself as a building block of digital computation’s operational infrastructure. As Ernst describes, “[c]omputer programming, the cultural force of today, is non-narrative; its algorithmic forms of writing – alternative forms of minimal, serial time-writing … are close to the paradigm of computing itself” (Ernst in Parikka & Huhtamo 2012, p. 252). Algorithmic lists in computation are present-based processing forms, lists of ‘etcetera’ that are inherently open, flexible and able to operate in real time as required by the computational networks of which they are a part.

Lists are part of the operational infrastructure of networks and databases, which are paradigmatic forms of a digital culture increasingly oriented around logistics: the movement of people, things, and data through space and time. The next section will explore aspects of logistical modernity that are outgrowths of list capacities at the heart of programming activities.