Abstract

Looking at crochet patterns, crocheting embeds similar features as algorithms and coding.  What could computer-generated crochet instructions look like? What would it feel like, when a device is programmed to give the crocheter the next instructions and the crocheter is the physical extension of the device? In my project „The Crochet Protocol“(2022) I dived into these questions by writing a program with simple rules to create crochet instructions that will be transmitted to me through a wearable device. The motor vibrations of the device can only be felt by me, the wearer, who has to follow a new protocol and become accustomed to this new sensory feeling. The protocol was the result of experimenting with different approaches for translating crochet patterns into code and vice-versa. Through juxtaposing crocheting and code, I defined seven basic steps and formulated general rules that I put into code, which will generate patterns that seem random and arbitrary at times.

The Crochet Protocol

Introduction

What are the similiarities between crochet and code? What would it be like, when a device is telling the wearer what to do? 

As someone who enjoys both crocheting as well as coding, I was drawn to explore the possible connections between the two that I perceived. My project “The Crochet Protocol” (2022) consists of a wearable bracelet with an ESP32 and three vibration motors which are used to transmit generated instructions. The wearer is told through vibration signals the next instruction and it is their task to interpret these signals and follow the loops and decisions of the protocol.

This project is an exploration of the interaction between crocheting, the code, the wearer and the controls through the machines. Is it possible to translate code to crochet or vice-versa? What does it take for the wearer to learn and understand the instructions given through the wearable device? What are the power dynamics in place or is it a collaboration between the machine and the wearer? And what is the sensory feeling and the implications of the bracelet?

The protocol is previously agreed on with simple rules. The creative choice regarding crocheting is taken away from the wearer and they are simply reduced to completing the work imagined and timed by the device.

Crochet

Within the crocheting communities, it is widely agreed on that crocheting cannot be easily replicated by a machine as “there is no similar mechanism for making the transverse chains that are another definitive attribute of hand crochet. A machine that can produce true crocheted fabric therefore remains to be devised.”[1] Therefore, crocheting lends itself perfectly to the scenario of the machine in need of human labor. “The Crochet Protocol” in this way also explores the idea of collaboration or interplay between the machine and the wearer.

Experiments

As Capunaman, Bingöl and Grusoy have pointed out in their exploration of three-dimensional crocheted objects, crocheting has computational aspects[2]. In my own research within the two-dimensional space, I started testing different patterns and instructions to combine crocheting and programming.

In order to explore these aspects, I early on experimented both to crochet from code and code from crochet. I attempted to crochet a Processing code pattern with different approaches and also write Python code based on crocheting. Processing and Python were chosen based on my own preferences, but also to test both a more graphical and a less graphical program.

Approach 1:

Approach 2:

Approach 3:

#What would crocheting maybe look like in Python? 
#Speculative code that is not working
#Classes for different Parts

def magicRing(length):
    chains = []
    for chain in range(length):
        chains.append(chain: )
    return chains

class Ball:
    def __init__(self, size, increase, color):
        self.size = size
        self.color = color
        self.increase = increase
    def create(self):
        chains = magicRing(self.increase)
        start = 1
        while start < self.increase:
            for i in range(len(chains)):
                if i % start == 0:
                    chains[i].append
                    chains[i]=chains[i]+2
                else:
                    chains[i]=chains[i]+1
            start=start+1
        
        for j in range(start):
            chains[i]=chains[i]+1
        
        while start > 0:
             for i in range(len(chains)):
                if i % start == 0:
                    chains[i].append
                    chains[i]=chains[i]-1
                else:
                    chains[i]=chains[i]
             start=start-1

Approach 4:

#I translated a crochet pattern to a functioning code 
#and then to crochet again using the output of the code
#Dishcloth pattern: https://easycrochet.com/free-dishcloth-crochet-patterns-and-printable-tags/)

def chain(length):
    chains = []
    type = 0
    for i in range(length):
        chains.append(type)
    return chains

class Cloth:
    def __init__(self, size, color):
        self.size = size
        self.color = color
        self.rows = []
    def create(self):
        self.rows.append(chain(self.size))
        for r in range(0, self.size-2):
            row = []
            if r == 0:
                for i in range (0, self.size+1, 2):
                    if i <= 2:
                        row.append("")
                    else:
                        row.append(2)
                        row.append(3)
                row.append(0)
            else:
                for j in range(len(self.rows)):
                    self.rows[j].reverse()
                row.append("")
                for i in range (1, self.size-1, 2):
                        row.append(2)
                        row.append(3)
                row.append(0)  
            self.rows.append(row)

newItem = Cloth(10, "black")
newItem.create()
for x in range(0,len(newItem.rows)):
    print (newItem.rows[x])

Protocol

I broke down popular crochet stitches and steps also found in crochet notations to their basics movement (see https://docs.google.com/spreadsheets/d/1Bqoj4yJnIEDEMROQp3zw3_mAoLq0HDatov8IfFlScu4/) and decided on a protocol consisting of seven different instructions:

By looking at the established crochet notation and the language used within written patterns, I decided to break down these stitches into the most basic and essential movements rather than treating multiple movements for a stitch as one instruction. I perceived the established crochet symbols and stitches as a “high-level language” within crochet. If I take the analogy further, I’m interpreting this high-level language like a machine and automatically breaking it down to the steps my hands have to follow. While describing stitches to beginners, these movements keep coming up in various patterns and are being named in similar ways.

On a higher level, these signals represent the common steps that underlie every stitch: insert, loop, pull through, left, right, front, back and are represented as numbers for the device and symbols for a visual representation. Looking at these steps as numbers, the device then again transforms them to the vibration signals using the three motors.

The rules for the pattern instructions in “The Crochet Protocol V.1” introduce randomness and unexpected, arbitrary behavior, so the crocheter is not guided by experience and anticipates a design but listens closely to the instructions.

Rules:

1. Make a slip knot on your hook.

2. Always start with N*chains

3. Each row stays within a +/-5 margin of total stitches

4. The same row style is repeated N* where N is smaller then maximum defined total row number

5. After each row follows a turn

6. Whenthe total max row number is reached, finish off with pull through

Sketch version 1: https://github.com/juliavollmer/TheCrochetProtocol

Device

The device is capable of producing patterns with the same set of rules. Through three vibration motors, the seven steps are communicated to the wearer. The bracelet device consists of a PCB featuring an ESP32 with WiFi, an accelerometer, a power management system, three coin vibration motors, switches and a small compact Li-Po battery. To secure the motors in place and guarantee close contact to the arm of the wearer, the bracelet is secured with three crocheted bands that allow individual adjustment for each of the motors for various arm sizes. Additionally, the battery is discreetly woven into one of the bands.

The protocol translates to the three motors (M1-3) in the following way: 

The motors are placed around the wrist with some distance to make a distinction possible. If they are placed in too close proximity the motors will feel as one. The number of motors reflects the minimum amount needed to translate seven instructions and to keep the device in a wearable size. Through this translation, the wearer has to process the motor instructions again to translate them back to the movements they have to follow.

Wearing the device

The bracelet is mostly designed for people with crocheting experience, but others can attempt to follow the instructions as well. Upon first wearing the bracelet, a settling-in period is needed to fully become in tune and recognize the differences and changes of the vibration motors.  At first, the signals seem to be very hard to distinguish but through longer usage, the body becomes adapted to the bracelet and gets a new “sense”  for the vibrations.
For practising purposes, I first go through all seven different instructions to get to understand the sensory feeling of each of them. Then I test myself  to see how well I can identify the instructions. It takes me several attempts to be able to distinguish the motors, but the more I wear the device I feel enjoyment and fun from understanding the instructions.

The moment I start to actually follow real instructions, the signals appear in somewhat predictable patterns, making it easier for me to follow. While at first the predictable patterns feel slow to me, there is the insecurity of not being able to anticipate the next step in case it will break the pattern I thought to have identified. With the tactile instructions in comparison to visual instructions, there is no way to look ahead to the next step in order to comprehend the instructions better. I have to trust the process even when I feel confused.

The moment  the instructions are not following my own expectations, I notice myself making the decision to disregard the next step and doing what feels correct, in order to not fall behind. The device adds a temporal component to crochet instructions that requires me to adjust the pace of my crocheting to the instructions and therefore giving the device more power. As the device is continuously moving forward, at times I struggle to keep up and start to panic before I get into the rhythm again. Through this I’m diverting from the pattern instructions and adding human error within the crocheted item. These unexpected situations create new, sometimes exciting experiences and break the redundancy of following the robotic repetitions of the device. As the shape slowly starts to emerge I find myself trying to work slightly against the instructions in order to have an effect on the crocheted item.

It is within these moments that I feel the dynamics between me and the device shifting, I can not simply keep following the instructions and make decisions of my own before getting back to simply following the devices’ instructions. The finished item is not my focus while crocheting and I’m more attuned to the pattern and simple steps. Through this whole process I do feel bored at times and not knowing when the pattern will end can become tedious.

When taking the device off after wearing it for a longer time, my arm can still feel the vibrations like a phantom. After I’m finished, I regard the making of the item more interesting to me than seeing and having the crocheted item. The idea of producing something with crocheting is less relevant to me while using this device than the act of crocheting itself.

The making of the instructions was a reflective activity that allowed me to observe stitches closer and analyse them further through trial and error. With the device and the fragmentation of stitches into steps, I do feel an even stronger connection between coding and crocheting. I have to further process the device’s tactile instructions to translate them into my own body’s movement mimicking similar processes within coding.