This post is part of a series focused on exploring DVS 2020 survey data to understand more about tool usage in data vis. See other posts in the series using the ToolsVis tag.
In the last post, we talked about a series of explorations using gathers in fabric to inform my understanding of the data structure that I’m looking for in the tools visualization. In that first exploration, the gathers were added into the fabric after the fact using embroidery, but there are also ways of building gathers into the fabric directly. That got me thinking about weave structure, and prompted me to return to a weaving project on my list that has been in hibernation for nearly 5 years.
As you’ll see, this is a much larger detour than the last, and so I needed to be fairly certain that it was going to provide value before embarking on this journey. The embroidery experiments confirmed that hunch, and so I decided that it was worth setting out and seeing where it goes. This post will talk just about the loom setup and some of the steps required, and the next will get back into the data vis and what I learned about tool visualization along the way.
After seeing the results of the first set of gather experiments, I was pretty sure that simple gathers weren’t the approach that I wanted for this project, though there are lots of interesting things to be explored with that as a separate area of interest. Instead, I kept coming back to the core insight that this visualization should be a series of temporary states built out of a common structure (notes, fabric, threads) and manipulated based on the query of interest. Weaving is an excellent technology for thinking through this kind of problem. It is a very structured, sequential craft, with several interrelated pieces that come together to create the final design. There are clear decision points, and many of the configurations are flexible once the piece is set up, which means that you can iterate fairly easily to understand the implications of what you’re doing. Because it is fairly complex, weaving also has a sophisticated set of annotation systems that can help you to think through a problem more clearly.
I often like to use a physical medium in my early explorations to test my conceptual understanding of a problem. Mistakes and misunderstandings show up easily: the materials themselves will contradict you if there’s a problem. You might be able to imagine that two planes intersect and miss some aspect of perspective, but when you’re holding a sheet of paper in your hands, that ambiguity often goes away. This clarity makes it much easier to error-check and think through unfamiliar terrain, compared to a fully abstract representation where you could be days or weeks in before you realize that your first step was all wrong. My approach to this particular problem is also influenced by the fact that I am trying to wrap my head around R at the same time as this dataset, and I think that the analogy between weaving and functional languages will help me to understand how to frame an approach to functional coding, which is quite different from the object-oriented languages that are more familiar to me.
First, a few terms: in weaving, fabric is made up of two sets of threads. The warp is the thread that goes on the loom. It is tied on in a particular order, and that sequence of threads does not change (there are a few exceptions where you manipulate the warp order for more complicated patterns, but we’re going to ignore those here). Each warp string is threaded through a heddle, which is a static holder that connects series of threads to the loom shafts. The shafts hold the heddles, and basically act as filters on the warp, allowing sets of threads to be lifted systematically in sets. The threading pattern is established by choosing which shaft each warp thread is attached to. Sets of shafts can be lifted together to achieve more complicated patterns. In some looms, the shafts are lifted manually, but I’m working on a floor loom where those relationships are more fixed. A series of tie ups determine which shafts are raised together. Together, the threading pattern and tie up determine the basic structure of the fabric. All of these pieces are part of the loom setup, and don’t usually change once a project starts.
Warp threads on the loom:
Each warp thread goes through a heddle, which attaches it to the shafts.
Shafts are grouped to treadles using tie-ups.
Raising shaft groups creates a shed.
Next comes the actual weaving, which requires a weft. The weft is a second set of thread, wound onto a shuttle or other holder that gets passed back and forth through the space between warp threads that’s created when a shaft is lifted. That space between layers of warp threads is called the shed. You create the shed by raising shafts singly or in groups. The tie up determines which ones can be raised together, and the treadling is the sequence that you use to raise them. The tie up is usually fixed, but the treadling can vary as you’re working on the loom – think of this as applying different sets of filters in sequence once the data is loaded. As you weave, you use the treadle combinations to raise the shed for the different patterns. You can treadle all day to lift the shafts and put them back down, but without the weft thread those filtered states will be temporary (pick threads up, put them down), and you won’t actually get fabric. It’s only when the weft threads lock the shed patterns in place that you get fabric.
When you pass the shuttle through the shed, it leaves the weft thread behind it. Depending on which shafts you raised to create that shed, some threads will be above the weft thread, and others will be below it. This creates the patterns that you see in the final woven fabric. In some sense, the fabric is a history of all of the filter states that you have applied, and the order in which you applied them. The act of weaving is just a matter of applying those filter states in the right combinations at the right times, and then locking them in place with the weft, so that you can see the results in fabric. Treadling different patterns will create different designs in your woven piece.
I chose a double weave structure for the project that I wanted to use as an exploration here, because it has some additional variables (read: more complexity) that I thought would be helpful for thinking through this particular problem. In double weave, you actually weave two (or more) layers of fabric at the same time. This is important because it allows you to weave patterns that wouldn’t create a stable fabric otherwise: you simply hide the pieces that you don’t want on the other layer. To create the patterns that I wanted in my final piece, I needed an extra level of hierarchy in the warp setup, creating design blocks to manage the different layers. It was that additional layer of logic that felt like it would be most useful for understanding what was really going on in my tools dataset.
I’ve woven double weave before, but only once or twice, and it’s been a long time. The first step was re-reading a book on double weave structures, and working my way through the various annotations to make sure I understood what they did. In hindsight, drawing out the weaving pattern step by step was the single most useful part of this detour, because it helped me to get my head in the right place to actually understand the problem. Learning to feel the embodied rhythm in over 40 hours of weaving was helpful as well, because it helped me to develop an intuition about how all of these abstract variables work together to produce the outcomes that I want.
The first part of setting up the weave structure is understanding the threading pattern (warp goes through heddles to connect to shafts). For doubleweave, that’s easy: I wanted to use a plainweave fabric on both layers. Plainweave fabric can be woven on just two shafts: one set of threads is up, the other is down. You weave the fabric by lifting first one shaft and then the other. If you want two layers of fabric, you need 4 shafts: two for each layer. In this project, I also wanted two blocks (two sections of fabric) that I could control independently, so I used 8 shafts instead. I only have 8 shafts on my loom, so any more than that complexity would require coupling between blocks, which I didn’t want to do right away. If I didn’t care about the blocks being independent, I could have fit everything in the first set of samples onto only 4 shafts, leaving me another 4 for managing more complex patterns, but I wanted to maintain the freedom to experiment, so I didn’t jump that far in the first go.
For this particular project, I wanted to use color in addition to structure to get the pattern that I want (I’m actually working toward a designed fabric here, in addition to just playing around on the loom). When you’re working doubleweave, it can be hard to keep track of which layer you’re working on. One way to help with that is to have different colors in each layer, so that you can always check to see which set(s) of threads are where. For simplicity, I chose to work with 4 pairs of colors, with a light thread and a dark thread in each. Depending on how I manage the tie up and treadling, this allows me to weave a layer of light fabric and a layer of dark fabric, or two layers that are mixes of light and dark. I spent a little while mocking up basic options in Illustrator, to get a sense of what the final fabric could look like, and decide which pairs to use in the sample.
Once I had the basic color pattern figured out, I could wind the warp (this is just measuring out all of the threads that are going to go onto the loom, and it sets the length of your final fabric).
From there, each warp gets threaded through the heddles, and attached to its proper shaft. For this project, each warp pair contains a light and a dark thread, which helps to tell the layers of fabric apart in the final weaving.
Once the loom is set up, you can change the treadling and the weft color sequence to make different patterns in the fabric.
You can get quite a variety of patterns from one warp.
The process of thinking through the setup and weaving these samples helped to sequence and structure my thinking about the tools visualization in very helpful ways. I’ll talk through that in more detail in the next post, and explain how this process is starting to affect how I think about both the data and its visualization.