over/under

Over/under explores the connection between weaving and programming and the almost mystical connection between women and software writing, embedded deep in women’s tradition of weaving not just threads, but networks.
Following this thread [pun intended] through the history of computing, I discovered the Jacquard loom, invented in 1804 by Joseph Jacquard. His mechanical loom worked with a deck of punch cards which controlled the pattern which the machine executed. This was the first instance of a programmable machine. Later on, Charles Babbage’s Analytical Machine was designed to be able to perform all four arithmetic operations, with the use of a similar punch card system. This technique was further developed for the US census in 1890 by Herman Hollerith, whose company later became IBM.

The connection between weaving and programming can be represented through an equation:
input + rules = output
In the case of weaving, the input is thread, the rules are the pattern, and the output is fabric. In the case of software, the input is data, the rules are the sequence, syntax, etc, and the output is data modified according to the rules. In order for this connection to be stronger, it is necessary that anyone who analyzes the output and knows the available rules can retrace all the steps that were taken in the process of weaving/programming.

I wanted to be able to reveal the rules applied to the input through the output, by tracing back the instructions line by line. To do this in software form, the instructions had to be written in a language that was simple and straightforward, one that emulated weaving instructions as closely as possible.
From all this came the writing of an interpreted programming language in Python that could receive as rules basic weaving instructions ‘over’ and ‘under’ and apply a pattern onto text, simulating a plain weave. For the command ‘over’, the pattern would show the respective characters as they are. For the command ‘under’, the respective characters would be replaced with an unicode character. The code is adapted after Peter Norvig’s code on writing a Lisp interpreter in Python.

When running the program, an interpreter is opened, with the use of the repl function. After that, the program is ready to take commands. There are currently 8 commands for the over/under language.

• load
• show
• over + int(x)
• under + int(x)
• pattern
• save
• enter/return
• quit

loads the input text
shows the current line
keeps x characters intact
replaces x characters with a symbol
generates the pattern
saves the pattern in a .txt file
pressed twice, moves you to the next line
quits the program

e.g. over 10, under 9, over 8, under 7

Instructions

I grew up playing with paper weaving patterns, which inspired this project

$ python3 overunder.py
> load
> over 1, under 5, over 1
>
> over 2, under 4, over 2
>
> over 3, under 3, over 3
>
> over 4, under 2, over 4
>
> over 5, under 1, over 5
> save
> quit

This project was done as part of the OuNuPo Special Issue 5, Piet Zwart Institute, Experimental Publishing
See more at:
issue.xpub.nl
Get the code at:
git.xpub.nl/alicestrt/overunder

alice strete/alicestrete.me