Lexicon / goto

Douglas Edric Stanley


source code: drawto

The expression GOTO has forever been burned into the retina of an entire generation of programmers. GOTO is the command instructing a program to jump to another position within the program, whether to instantiate a loop of the program itself or to bifurcate to another position within the program, for example in response to interior or exterior data.

Simply put, the GOTO expression moves the computer spatially to a different place and tells it to do whatever is written there.

For many, in order to learn BASIC one had to begin by writing the following lines:

20 GOTO 10
BASIC 'Hello World' program

This program displays the words “Hello World!” on the screen over and over, until the program is forced to quit (cf. 10 PRINT MAEDA).

The extreme version of this logic can be expressed with the following code:

10 GOTO 10

Here the program loops onto itself, without any information being sent to the screen. The program gives the impression of being stuck, for its does nothing else than to infinitely go to the instruction that instructs the computer to return to itself. The impression of having stopped is based on having no external information displayed to us that the program is doing something: we see the computer do nothing, whereas for the computer it is in fact extremely active. It is enacting the program that tells it to do the same instruction over and over: return to itself. This returning to itself is one of the fundamental acts of early programming techniques, and by slipping a few extra instruction into that very tight loop, we can in fact create the impression of an evolving, active, and very reactive computer. It is in fact often the way in which a computer game is built.

Of course, GOTO can also be used to modulate the computers activity. For a bifurcating use of GOTO, the use of the if…then…else is required:

25 GOTO 20
35 GOTO 30

In spite of a few reappearances in environments such as Flash or Director, in the age of object-oriented programming, GOTO has more or less been banished as poor programming style. As we abstract ourselves more and more from the functioning of the machine, it is not suprising to see GOTO disappear little by little from code. For the GOTO works at one of the lowest levels of the machine — go to location x and run the instruction located at that starting point. This idea, of running a specific section of code starting from some point x, is so fundamental to modern computing machines that it is difficult to understand how they might work otherwise, even if we do attempt to place more and more levels of abstraction between ourselves and these low-level processes.

GOTO is also a significant component to the Turing Machine, as well as one of the most fundamental and difficult computer languages, assembly language. In fact the entire Turing Machine itself is based on the idea of moving to the left or to the right on the eternal ribbon depending on the current value square. This move is essentially the same as a GOTO.

Yet another idea that the GOTO introduces into programming is the idea of an absolute contingency, in which any line of code can lead to any other line of code in any context without hierarchy. This does not mean that all events are equal, but it does mean that unheared-of relations can emerge. This contingency is tightly related to the spatial nature of the GOTO : you are here, now go here. GOTO suggests that computer programming can be understood spatially as well as conceptually, i.e. as occupying a plot.

Many of the early adventure games — programmed in BASIC — tapped into this logic, allowing users to explore the code linearly — thus creating a narrative — all while jumping around spatially throughout the code. By reading from lines 1 to 100 of the program, the computer would print out phrases such as, “You are in the woods”, “Trees block your access”, or “a path leads north”. By answering the right questions, the player could get the computer to begin reading from lines 100 to 200 of the program, where phrases might ressemble “you are standing before a castle”, “there is a moat”, “aligators are writhing about in the moat”.

The beauty of the GOTO, seized upon by the early adventure games, was that through a non-linear reading of the linearly organized lines of code, a new form of linearity was constructed: the linear adventure narrative, i.e. the iterative succession of events that the player enacted by moving on to the next one. The player saw a linear progression of his or her movements (go north, pick up straw, open soda can, use straw to drink, grow smaller, enter hole), all within a non-linear reading of the computer code. In this sense, GOTO re-linearizes the discrete, spatially non-heirarchical nature of the computer, albeit through the form of a zigzag.

One last point. If the GOTO introduces a new form of linearity, it does so solely trough a process of successive displacements, in other words without end. The GOTO exists only if it continues to GOTO, one GOTO after the other, giving birth to the conditions for an internal achilles heel in the machine. In an adventure game such as Open Sound Control., the game is interresting only if there are new levels to conquer: once the princess has been saved, the game loses all its narrative force. This principle is in direct contradistinction to the cinematographic apparatus, with its tendency to drive its narrative precisely to the point of its own extinction. Contrary to the finite cinematographic filmstrip, the GOTO has no other stopping point than the trap of the loop that is too small — i.e. the infinite loop — or by unplugging machine. It is able to move about infinitely within the finite space of the machine, but contrary to the filmstrip, there is no structural end integrated within the GOTO: its end is solely a precondition to its dissapearance, pure and simple.

It is no suprise that projects such as Red vs. Blue have arisen, as well as a multitude of artistic reappropriations such as How To Win Super Mario Bros, Prepared PlayStation or Super Mario Clouds, as well as a plethora of game exploits in which playing the game becomes an expressive performance — often turning the game’s bugs and defects against itself, or trying to play the game as fast as possible even if it means cheating — rather than seeing the game as one expressive whole leading to a conclusion. These activities turn the game back into a looping or cyclical form, more in line with the infinite nature of the GOTO.