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.
After the last post, I decided to do a little hands-on exploration in the physical world, using the metaphors that came up while I was reaching for ways to describe the problem. Gathers in fabric and notes on a piano are both temporary states based on an underlying structure, and I wanted to have a more concrete sense of what those ideas meant.
This is the part where the project manager in my brain starts to feel anxious. “Don’t we have somewhere else to be? Is this really worth the time?” But this is an exploratory project, and so the answer to the first question is: no. We have nowhere else to be, and this is the path that feels right to me, right now. I don’t know if it will be worth the time, but it’s not going to take that much time, I can stop whenever I think it’s outlived its usefulness, and my gut tells me that this will help me to understand the problem in a different way. Projects need to talk to each other. You always want to leave enough space and time for inspiration to come from different sources, because your solutions will be stronger and more robust if you do.
Playing around with some physical visualization is also a way to get out of my computer and to create space for this project in a different part of my life, which helps me to stay engaged and not burn out before I get to the end. It’s possible that this little detour will be a complete waste of time, but I’m ok with that. I can afford a week or two to follow up on this lead, and I can always drop it if it fails to bear fruit.
I am very strategic about when and how I engage in a detour, and when I stop to fill in all of the details on an individual piece instead. It’s a little like adding in layers in a watercolor painting; you usually want to put down even layers across the whole piece, rather than developing all of the details in one tiny section (unless that’s a specific look that you’re going for), because color and light work best in conversation with the rest of the piece. If you zoom in too fast, you’ll likely misjudge the tone balance, and it will be harder to fix without damaging the details. Too many detours just wastes time and dissipates energy, though, so it’s important to develop an instinct for when something is going in an interesting direction.
In this particular case, my explorations with the reduced branches visualization brought me to the idea of gathers in fabric, and tickled some part of my brain that remembered this:
My grandmother made the dress that I’m wearing in that photo, using an embroidery technique called smocking. The method is not in common use today, but smocking was once an important part of making wearable garments, in the days before elastic. I suspect that my grandmother learned it from her mother, who was a first-generation immigrant to the United States. She was born in 1907, a year after my great-great grandmother immigrated to America from Italy with her new husband, carrying a dowry of linen fabric woven on her family’s farm to begin her life in the new world. The family language and even their names were victims of assimilation: Assunta became Susie, and married Erminto, who became Ernie, or Eddie…different people called him different things. When asked which name he preferred, his answer was to shrug and to say it didn’t matter, call him whatever you like. My grandparents grew up with a firm dictum: “you’re in America, speak like an American.” By the time he died at 97, my great-grandfather no longer remembered how to speak the language of his birth. Against that backdrop of deliberate cultural amnesia, traditional embroidery methods survived, passed from mother to daughter across the years. In that dress, a living seed passed on to me without any of us knowing it, and it chose this moment to sprout into a new idea: 30-plus years later. You just never know how an old idea will take shape, when planted in new soil.
To me, this is an example of why it’s important to bring your whole self to a problem, and to allow those dim flickers of memory a chance to have their say. It’s this kind of richness that we lose when we force ourselves into a single, rigid approach to a problem, as is so common in formal education. I don’t know that this insight is important, and it would be easy to brush these explorations away as “hobbies,” “women’s work,” or a waste of time rather than taking them as serious routes to insight. I can guarantee you that if I brought smocking up as an analogy at work, no one would understand why it’s relevant. It may take me more time to explain why I’m poking around here than the insight itself is worth. But to dismiss it would be to deny the power that diversity brings: the capacity to see something where someone else cannot — even if it is only a glimmer, and even if it turns out not to be worthwhile.
I have learned to trust my instincts for things like this, and I find that I almost always learn something when I follow where they lead. And so, in the spirit of using my unique insight in the service of solving a problem, I began plotting out points for the gather threads. (And no, I didn’t bother to iron the fabric. That would have taken valuable project time that I didn’t have.)
The smocking method itself is quite simple. You start with a grid of points, and then you create rows of running stitches across the fabric, picking up just a couple of threads with each one. In this case, I added in some thread management devices (made from cereal box cardboard) to prevent tangles and support the various contortions that I knew I would put this project through.
Next, I added in a second dimension. Because if you can have one, why not have two? It wasn’t hard to add the flexibility in at this stage, and I suspected that it might be useful as things got further along.
And here’s what happens when you pull the gathers, first the horizontal (white) threads, and then the vertical (blue) ones:
The second one also explains why they use a gathering model to make window blinds: there are all kinds of interesting technologies related to folds, gathers and pleats. Everything from clothing to cardboard boxes to sheet metal can benefit from structural folding patterns. If this is something that interests you, I highly recommend Paul Jackson’s book on Complete Pleats as a fascinating read (along with many of his other books).
You can probably also see from this first encounter with the gathers why thread management becomes such an important concern. Those little cardboard supports are priceless when you’re trying to create even gathers, or to reclaim some disorderly threads.
You start to get interesting patterns when you combine the horizontal and vertical gathers. Without tying the threads off permanently, uneven tension makes it hard to get clean patterns over a large area.
With a little patient finessing, I was able to get a larger, more even pattern. I also realized that using different patterns of gather threads all working together would have significantly helped to stabilize the gathers and to speed my work. No time for that now, but it’s an interesting tangent to explore another day. (I’ve added it to the queue.)
Right now, all of the action is taking place on the back side of the fabric, but it never hurts to turn it over and look at the front side, too (this is where the embroidery would go, were I doing an actual smocking project).
There are two things that interest me here. First, it’s not the gathers themselves that are meaningful; it’s the patterns that come from multiple gathers working together that create the effect. Even small disruptions in the order are quite visible, and small changes can cause the whole pattern to break down. This sort of behavior often lends itself to blend modes and building up semi-transparent layers: if I went with a visualization based on this approach, I’d be thinking about how multiple paths can add up to a more interesting whole.
The pattern instability is partly because I have not used more advanced structures in my stitching; if I had a second set of threads with a different stitch pattern, they would help to stabilize the folds. The simple grid is more flexible, but it’s also harder to configure.
The second thing I notice is that all of this distortion is happening in the Cartesian space of my grid, and not in the points that represent my data. I haven’t even added those in yet, and already I have this very strong pattern ready to swamp out my signal with lots of noise! So that’s something to be careful of, and a reason to be cautious about my earlier hunch that the gathers themselves were the important piece. I’m not done exploring yet, so I’ll just put that observation aside for later, but I am now pretty certain that my initial musings will lead to a dead end, or at least to an unexpected bend in the road. Still, those hunches have carried us this far and there are more interesting things to look at while we’re here, so let’s see what else we can learn from this little foray into fabric and thread.
Next, let’s add some data points. Remember that this approach is built off of some experimental parallel y plots. I’m trying to understand how best to deal with “threads” that might skip over the individual axes.
In fabric, that’s accomplished by simply skipping certain grid points, so that the individual data lines (in dark green) will only gather at certain points.
As I had begun to suspect, the gathers here didn’t lead to anything particularly insightful. They’re not telling me about the data; they’re just telling me about the fabric. I am 100% sure that there are some cases with highly structured datasets where emphasizing the gathers would work really well, but it’s doing nothing for me here.
So, what else can we do with this, before we move on? We can add an encoding element to emphasize the skips.
Or we could choose to emphasize the points, instead.
As long as we’re playing with beads, we might as well add in some color.
Here, I’m assigning color based on sequence from the beginning of the thread. You could assign it other ways, though: either by point type or stitch column, or a variety of other things. The sky’s the limit, really. Or, you could treat the points the same, and instead emphasize the threads that connect them. Here, I’ve tried doing that in a second dimension.
In this case, all of the beads are equal, but there are a different number in each row. The rows are collapsed down to ignore sequence and focus on length, but a secondary thread connects related elements between rows. This sort of orthogonal indexing feels very promising to me, but I’m not sure yet what to do with it, so I’ll leave it here for now.
I also thought about what it might look like if the grid itself were beads, rather than stitches. This has intriguing possibilities for using the data threads to “gather” up collections of beads, selecting the connected elements out of an otherwise structured grid.
You could do that with undifferentiated beads, so that the threads become the important information, or you could assign meaning to the grid elements themselves.
Once you’ve created a grid with values, gathering along an individual thread gives you a profile of categories for that thread (note that it loses the additional dimension of which row the bead is in, which may or may not be important). You can “analyze” for a single thread by tightening the gathers, and you can analyze multiple threads at once.
You could consider leaving the grid entirely. If you group the beads and allow the threads to connect them, you’ll end up with a node-network structure instead (and interesting questions about directionality and sequence in an unordered space, analyzed with a single directional thread).
The key thing for me here is to get a sense of the different possibilities, not to select a final “best” option or even to ultimately use any of these solutions. This is just sketching in a different way, using physical materials to teach me things about the dataset and about the visualizations that I might not have gotten to if I’d stayed entirely in my head.
At this point, I feel like I’ve done a reasonable job of exploring the different options available in this medium, and I’ve gained a couple of useful insights that might help to guide my next steps. I have about a million ideas for follow up projects, but those can wait for another day. For now, I’ve gotten what I need. In total, I don’t think this project took more than 5 or 6 hours to complete, and all of the materials are easily reclaimable (except perhaps the thread and cereal box cardboard).
A couple of afternoons playing with craft supplies didn’t really take a lot of steam out of my project, and it helped me to stay engaged with exploring the problem while taking a break from the analysis and catching up on some of the writing. I often use these structured explorations as a way to give my brain space to crunch away on a complicated problem; it helps me to keep thinking about it, but also helps me to refrain from pushing when things aren’t yet ready to be forced. I don’t tend to spend a lot of time or go very deep into these little detour projects, but they do help me to keep up energy and momentum through the difficult parts of a problem, and to bring in new viewpoints along the way.
Things I learned:
- Gathers are interesting, but they’re probably not the solution that I’m looking for here. I’m more interested in the data points than distortions in the grid space.
- Using gather threads to pull up interesting data points in malleable collections seems applicable to this project. That one may be worth coming back to.
- I think the emphasis here should be more on the beads (tools), and less on the strings that connect them. The threads in this case are just aggregating bundles, meant to group like tool sets together. If I wanted to tell a narrative about an individual person, that might be different; it might be interesting to consider the possibility of using selection or highlighting to allow a viewer to pull out individual threads from the bundle.
- Indexing the same bead collection with orthogonal thread sets seems like it might be promising; it may be worth coming back to that one, when I have a better handle on what problem I’m trying to solve.
- Thoughtful structure is the difference between a complex visualization and a tangle (aka a hairball). As someone who works regularly with lots and lots of threads, I can tell you that order, repeatable structures, and sequence of operations is often the only difference between a fun project and a hopeless mess. Proper string management (filters and selection are the appropriate analogies in this case, I think) is how you get useful information out of the noise. More and more, I suspect that this visualization might have to have all of the data points in it to be valuable, so this will be especially important to remember when we get to the solutioning stage.