Quagmire

An art project where drawings draw themselves.

Quagmire is an emulation of an impossible 8bit processor, where all memory is addressed in 2 dimensions, and is represented by pixel value. Program execution threads can run up, down, left or right. Sections of code are visible in memory, as are the processes as they run. Unlike a normal computer the internal process of the machine is visible. Programs are drawings.

In this system, crashes can be viewed as they occur, processes can write all over each other, or themselves. Lost threads of execution wander through memory, running any data they meander over.

Drawings

Fork Exec Exit

This is a series of artworks documenting some of the experimental drawings/programs I have tried with quagmire. In these pictures, the memory contents is shown, with the program threads overlayed as white pixels. Memory is cleared to white (value 255) to make things easier to see, as most instructions are nearly black. The first thread always starts at the bottom left corner heading from left to right.A test program to broadly emulate the actions of the commands fork, exec and exit in a unix system - ie copy the code to another location, spawn a new process and exit the parent process. As the new thread is spawned at 90 degrees counter clockwise to the parent, after the 3rd copy, a new process is written in exactly the same position as the original and the drawing is infinitely repeated.

Broken fork bomb

A fork bomb is similar to the program above, except it forks multiple copies of itself, which means memory will fill up and the machine will become inundated with processes. Unfortunately there is a bug in the program, causing the copied processes to overwrite each other causing a crash. Meandering through memory, a process thread manages to rerun the first program, but in reverse, writing to two memory positions in the centre of memory.

Self destruction

I thought of another, simpler method of causing mayhem. This program fills memory with a drawing (the x and y coordinates xor'ed, then and'ed) that eventually overflows and overwrites itself, after that I had no idea what would happen to the program thread. It skips into it's drawing in image 5, and then some localised order follows, lots of threads are spawned and then increasing chaos, as threads fall over each other, writing and executing. At this point I am not sure where the chaos comes from, there is no randomness in the system and it's entirely deterministic. Perhaps it's a pattern which is too hard for me to follow?

Fork bomb

Finally the fork bomb works! I've increased the memory so the drawings are bigger. Each process spawns two copies of itself, and the processes loop back over one another in a similar way to the first drawing. Eventually the copies begin interfering with one another, resulting in one or two lost threads. Interestingly, as the code is copying itself, errors are duplicated in the child threads. Eventually something goes very wrong, and a strange program is created which spawns hundreds of threads, which then go on to make some interesting marks, but eventually settle into a repeating pattern of behaviour.

Old Memories