User:Alice/Special Issue V

Reader #1

Title and topic

Techno/Cyber/Xeno-Feminism The Intimate and Possibly Subversive Relationship Between Women and Machines

My reader explores topics from women's introduction into the technological workforce, the connection between weaving and programming, and using technology in favour of the feminist movement. One major concept that appears throughout the reader is an 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], I continued my research in the history of computing, which led me to the Jacquard loom, invented in 1804 by Joseph Jacquard. This 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.

Production

I built this reader using only free software. It was designed using HTML and CSS, compiled using Weasyprint, and the cover was designed in GIMP. The printing was done at WDKA. For binding, I decided to keep in line with the concept of weaving, and use Japanese binding with cotton thread.

• 
• 

Research

Research questions:

• Does software have a gender?
• What elements and concepts are revealed when exploring the connection between weaving and programming?
• How have women challenged the imbalance in gender representation in technology?

List of works

In order of appearance in the reader:

1. When Computers Were Women, Jennifer Light

2. The Future Looms, Sadie Plant

3. Zeros + Ones, Sadie Plant

4. A Cyborg Manifesto, Donna Haraway

5. Where Is the Feminism in Cyberfeminism?, Faith Wilding

6. 100 Anti-Theses, Old Boys Network

7. Xenofeminism: A politics for Alienation, Laboria Cuboniks

Software experiments

Exploring further the relationship between weaving and programming, I looked at the perceived similarities between the two. For me, one of the best representations of this connection was 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.

• 
• 

Over/under

I was interested in the possibility 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, I realized that 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. Inspired to work on my own language after reading Peter Norvig's essay and code on writing a Lisp interpreter in Python. From his code, I selected a few bits that would be useful for my project, and learned the necessity of the parse and eval functions.

Walkthrough

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 overunder language.

• load - loads the input text
• show - shows which line you are currently working on
• over + int(x) - keeps the corresponding x characters intact
• under + int(x) - replaces the corresponding x characters with a symbol
• pattern - generates the pattern created so far
• save - saves the pattern in a text file
• enter/return - moves to the next line of text
• quit - quits the program

Outputs

I experimented with a couple of different characters for the under command, including unicode.

First output:

Second output:

Another output:

Code

import linecache
import textwrap
import sys
from sys import exit

class LeavingProgram(Exception):
    pass

def parse(program):
    cmds = program.split(',')
    splitted_cmds = []
    for cmd in cmds:
        splitted = cmd.split()
        splitted_cmds.append(splitted)
    return splitted_cmds

def tokenize(s):
    return s.split()

def repl():
    while True:
        try:
            val = eval(parse(input('> ')))
            if val is not None:
                print(val)
        except LeavingProgram:
            break

text = None
line_number = 0
last_index = 0

def eval(cmds):
    global text
    global line_number
    global last_index
    global pattern

    for cmd in cmds:
        if cmd == []:
            line_number += 1
            last_index = 0

        elif cmd[0] == 'load':
            contents = open('ocr/output.txt').read()
            text = textwrap.wrap(contents, 40, break_long_words=True)
            print('\n'.join(text))
            line_number = 0
            last_index = 0

        elif cmd[0] == 'show':
            print(text[line_number])

        elif cmd[0] == 'under':
            current_line = text[line_number]
            char_number = int(cmd[1]) - 1
            char_list = list(current_line)

            x=range(last_index, char_number + last_index + 1)
            for time in x:
                if time < len(char_list):
                    char_list[time] = u'\u21e2'

            last_index += char_number + 1

            joined = ''.join(char_list)
            text[line_number] = joined

        elif cmd[0] == 'over':
            last_index += int(cmd[1])

        elif cmd[0] == 'pattern':

            pattern = text[0:line_number + 1]
            print('\n'.join(pattern))

        elif cmd[0] == 'save':
            pattern = text[0:line_number + 1]
            pattern_file = open('output/patternfile.txt', 'w')
            pattern_file.write('\n'.join(pattern))
            pattern_file.close()
            print('Your pattern has been saved in the output folder.')

        elif cmd[0] == 'quit':
            print('Come back soon!')
            raise LeavingProgram()
        else:
            joined = ' '.join(cmd)
            print('Did not understand command {}'.format(joined))

if __name__ == '__main__':
    repl()

Going forward

• I would like to experiment more with creating programming languages, because this gives me a lot of insight into how languages are designed and all their inner workings
• I would like to explore ways of applying my project into physical form, and experiment with weaving directly, following the connection to software writing