A number of people have asked about the illustration titled RSG-FORK-5.1 that appears at the beginning of chapter three in Laruelle: Against the Digital. Part of an ongoing series of text pieces, some of which were also published at various places in The Exploit, the project uses code to produce unpredictable, recombinant patterns of text. These scripts were originally inspired by the work of Jaromil, whose :(){ :|:& };: fork bomb is particularly elegant and concise, along with Alex McLean and others experimenting with such recursive loops. Following the kind of net.art idiom evident in the work of Jodi (particularly their email experiments from the late 1990s), the project also draws inspiration from Carl Andre's typewriter pieces, the musical notation of Conlon Nancarrow and Gerhard Rühm, and the Bauhaus typewriter and textile patterns by Hajo Rose, textiles being some of humanity's oldest forms of digital encoding.
Presented in the classic form of the self-portrait, the illustration is an ASCII drawing -- a kind of pixel-based image using the letters and punctuation characters to approximate different textures and grayscale levels -- produced dynamically from a few lines of Perl code. (The code used to create each piece appears at the top of the file, to be cut-and-pasted and run by the viewer.) Created in the late 1980s by Larry Wall, Perl is a powerful text-parsing language, and in the early days of the Web it was one of the best ways to add server-side functionality to websites. After a bit of Basic and Logo as a kid, Perl was my first real language, and I retain a special fondness for it even now as the heyday of Perl has passed. I like the affinity Perl has with shell scripting, and of course Perl is still the most elegant and powerful language for regular expressions. It's a characteristically modernist language in this sense, the characters of code so effectively manipulated by that same code.
Forking is central in computational aesthetics and culture. It means either cloning or branching, depending on context. To fork a piece of code means simply to clone an exact copy. Some languages like Perl contain a fork function that allows a process to clone and execute a twin of itself. Or in software development forking code means that the codebase has been duplicated so that development may proceed in a different direction. (Such forks may eventually become merged with the original master copy, or the fork might remain separate and develop further into its own distinct application.)
If a piece of code calls fork then logically its cloned child, being an exact duplicate, will also call fork. This leads to recursion, with each process forking a new process ad infinitum. If left unchecked such recursive forking will quickly overwhelm the computer's memory, resulting in what are called “fork bombs.”
In fact it's rather trivial to crash computers. They do it on their own so frequently! What's more challenging -- and vastly more interesting -- is to strangle a computer, and in so doing produce something beautiful or otherwise intriguing.
The following is a simple example of fork recursion that erupts briefly before dying. It can be run in any terminal window with Perl installed, including the Terminal application on any Mac computer:
perl -e 'while (print fork," ") { exit if int rand(1.01); }'
The first part, “perl -e,” simply invokes the Perl interpreter and allows a snippet of code contained within single quotes to be executed in-line. The code itself consists of a while loop with an exit condition that occurs with enough irregularity to make things interesting. Inside the while expression, “print fork” (concatenated with a printed space) does two things at once. It forks a new clone of the code, and also prints the output of the fork, which happens to be the process number. The result is an irregular montage of spaces and numbers, many of which appear roughly in numerical sequence since the kernel simply increments a counter when it assigns a new process number. In sum, the first part of the code furnishes the stylus with which to draw, while the second part throttles the code just enough to avoid crashing the computer.
More firecracker than bomb, these snippets of recursive code produce generative textures using the terminal window. Minute variations affect the code, making it run differently each time. The processor speed, the number of other applications open, even the temperature of the motherboard will influence both the length and composition of the text. By slightly stressing the machine, but not crashing it, computer artifacts become visible as text.
RSG-FORK-5.1 uses slightly more code, and the file is more compositional than pattern-oriented, but the basic idea is the same. The following four illustrations display a lot of variety, but are produced by identical code.
