Overview

Key takeaway: Iteration is a ubiquitous need across many different visualization design workflows.
By "iteration," I'm referring to context switches in the design process—this can happen with respect to what you are currently changing in the vis design...
- such as iterating between editing the graphics of a visualization, and its underlying data as well as how you are making changes
- such as generating graphics automatically by writing code, and then editing them manually with a drawing tool I'm going to refer to these different ways of working as "modalities"
For visual design, practitioners often need to iterate between modalities; however, free-form iteration between modalities is difficult or impossible with existing software.
A similar challenge exists with respect to what we're editing, especially at the data level. We learn as we design, and learning that we need to change how we've been thinking about and structuring the data is pretty common. However, many data reshaping operations---particularly network wrangling operations---have support only in programming environments that may not be accessible to many visualization designers.
In this dissertation, we explore software and software models to make each of these kinds of iteration more feasible.

AVI

The need for better support for iteration was inspired by seeing things that suggest that graphic designers follow a process that is distinct from our own as visualization programmers
(pie charts)
This isn't an isolated incident—we see things like this all the time in infographics and the media, and while we can feel smug and blame the human all we want, we wanted to figure out why. The tools that the visualization community produces that would prevent things like this... don't really get much use, especially among graphic designers.
To better understand these issues, we conducted interviews, lab studies, and observations of graphic designers working with data
- Manual encoding has its benefits
- Placing data on existing graphics
- Tools for creating effective data abstractions*
- Relax the sequence of operations that software imposes*
  - Jim? Chris? quote

(Pattern from AVI: Using automation still resulted in manual work)
- Bang's figure + quote
- Isabel's figure + quote
What if you could go back and forth, minimizing loss? (define bridge)
Contributions:
- Bridge Model enables transitions between tools
- Outline the design space of strategies for software bridges
- Hanpuku: instantiation of a bridge between D3 and Illustrator
Hanpuku
- Interface intro (skateboard championship)
How to make this work?
Model + gist of how it works (circle diagram)
- Generative tool vs drawing tool changes
- Non-transferrable elements
Design space:
- How does a bridge identify what changed in each tool?
- How does a bridge merge the identified changes?
- How does a bridge reintegrate the merged results?
- How does a bridge infer designer intent?
Hanpuku's strategies:
- Identifying changes (talk about data binding)
- Merge strategies (two merges; override based on direction)
- Reintegrating results (D3 wasn't an accident)
- Inferring intent (both support grouping)
Key insight: recast the serial iteration problem as a parallel merge

We've shown how iteration can be possible w.r.t. graphics... what about the data itself?
Data abstraction is part of a vis design
- Chris AVI quote
- Benefits of working with data: Time travel dataset / experiment intro
  - Outliner
  - Repeated films
- Dangers of accepting the data as-is: HBO dataset (walkthrough!) + tabular charts
  - "I feel like I'm stuck in this treemap world"
We don't have good tools for iterating on data abstractions, esp. w.r.t. complex data like graphs

So what might graph wrangling look like? One operation: extracting subgraphs
What we mean by pivots (simple definition)
Why pivots + filters?
- General-purpose exploration technique
- Companion to the data wrangling process
- Extract manageable subgraphs
Tool demo
- Using NCAA data
- Interface walkthrough (don't include inability to pivot to all teams)
Evaluation goals
- Can pivots + filters enable novice users to extract subsets of a large graph? (without an instance-level topology view?)
- How does the technique obscure the overall network model of the database?
- Does the user understand the scope of the next pivot?
Participants & methods
- Mix of grad students and football fans
- Unstructured interviews
What we learned
- Smart pivot heuristic
- Learning from pivot + filter chains
  - Rich semantic meaning, conveniently encoded
  - Data-informed smart pivots?
  - Automatic data wrangling?
    - Infer new edges / attributes
- When are other views needed?
  - Local topology not needed for many tasks
  - Model topology important as a roadmap

Key takeaway: Iteration is a ubiquitous need across many different visualization design workflows.