We will look at strategies for implementing (creating) visualizations and how visualization can be used for exploring data (in addition to communicating stories with it). We will also consider design strategies for two common issues: comparison and scalability.

In Module 2, we consider the methodology of making visualizations. Implementation is a major component to this. We will also talk about process for thinking about two of the key challenges: scalability and comparison. Another aspect of methodology is how we handle exploration: making visualizations when the stories (or even the questions) aren’t completely known.

Discussing implementation is tricky: it can easily be too mired in specific tools. Instead, we will try to understand the kinds of choices available for implementation and try to inform the decisions about choosing tools. In class, we give students flexibility to choose tools that fit their needs. But we try to cover some of the basic strategies.

For design process, I focus on two concepts that I think are central challenges in most visualization design: scalability and comparison. We’ll introduce some (conceptual) frameworks to help you think about the approaches to these.

For exploration, we’ll postpone interactivity (which is typically the backbone of exploration) until the next module. Instead, we’ll talk about the statistical rammifications of exploring, and how this might influence how we think about data and design.

Over the course of the module, we’ll do a design exercise where you will make visualizations using the life expectancy data set (that you’ve already seen). The design warmup gives you a chance to make sure you can use some tools to make visualizations, and the design exercise will ask you to make real visualizations that tell stories.

Module Overview

A big part of this module is for you to identify the tools you want to learn about, learn about them, and then use them to make visualizations. You get to pick the tools (and what to read about them).

Also, I want you to try to use a grammar-based tools (just to experience the concept of grammars) - you’ll need to turn something in as part of the content survey.

Week 1 (Module 2)

Because of my travel schedule, the lectures will be re-ordered. We’ll talk about the basic concepts of implementation before the module starts, and use the first week of the module for class activities that follow up on module 1 (looking at actual solutions to the design exercise, and exploring high-dimensional glyphs).

In this week, the expectation is that you can start reading about implementation and choosing which tools you want to learn about and use in class. This is tricky because I want to give students flexibility to choose tools that fit into how they like to work (so you are likely to continue to use things later). Conversely, I want you to understand the range of different types of tools, and have a sense of when they are appropriate.

Warning 1: the “reading” includes a “watching”, and a bunch of picking your own readings (you pick the tools).

Warning 2: the seek and find requires you to have done the reading

Week 2-1 Readings

There are 3 parts to this week’s reading: general implementation, learning about toolkit you might use, and learning about design strategies. There is an experiential reading (one that I want you to read carefully).

Thing 1: General Implementation: watch this video of Prof. Dominik Moritz’s guest lecture in class in Fall 2020:

• Dominick Moritz. Dominick Moritz's Guest Lecture. (video from CS765 2020 - in Kaltura Mediaspace). (video)

Thing 2: Read about libraries you might use: I want you to read about 2 different visualization “toolkits” that might be relevant for you. I use the term “toolkit” to refer generically to libraries, packages, APIs, etc.

You should pick 2 things that you are likely to use. If you like to program in Python, pick 2 Python libraries.

I’d like you to pick a “high-level” (in terms of level of abstraction) toolkit and a “low-level” one. The concept of level of abstraction should be clearer after the lecture. Of course, you might not know the level of abstraction until after you read about the toolkit. That’s OK - think about how the two relate to each other (“high/low level” can be relative). (hint: that’s a reasing survey question).

Thing 3: Read about design strategies: Comparison and Summarization: These will be useful in designing visualizations, and are referred to in the assignments.

The key reading (that I really want you to read - it’s an “experiential paper”) is my Considerations of Comparison paper. The summary will get you the key points, but I want you to actually read the paper because I think the examples are good, and the depth and connection to other aspects of class is useful. And I am really proud of it. You can read the summary as well - but the paper is required.

• modern Michael Gleicher. Considerations for Visualizing Comparisons. IEEE Transactions on Visualization and Computer Graphics (Proc. InfoVis '17), 2018. (doi) (url) (Summary)

There is a related paper on summarization. For this one, it’s OK to read the summary, but you might want to skim over the paper as well:

• backbone Sarikaya, Gleicher and Szafir. Design Factors for Summary Visualization in Visual Analytics. Computer Graphics Forum 37(3) (Proceedings EuroVis 2018). (doi) (url) (Summary)

There are two book chapters that connect with this. There’s already a lot of reading this week, but do have a look, especially at Chapter 13. It’s a broader view of the summaries paper. These chapters are fairly short, skimmable, and they have a lot of pictures.

• backbone Tamara Munzner. Reduce Items and Dimensions. Chapter 13 from Munzner's Visualization Analysis & Design. (Canvas File) (video) (UW Library) - Scalability strategies
• backbone Tamara Munzner. Embed: Focus+Context. Chapter 14 from Munzner's Visualization Analysis & Design. (Canvas File) (video) (UW Library) - Focus+Context is a scalability strategy

Week 2-1 Assignments

• Reading Survey 2: Implementation and Methodology (due Fri, Oct 09)
• Seek and Find 2: Too much stuff (due Fri, Oct 09)

Week 2 (Module 2)

We will continue our discussion of tools. I’ll say more about toolkits, and show of Tableau. (in case you want to try it - see Tableau Access for CS765).

We will also talk about comparison, scalability, and how these apply in your work.

Week 2-2 Readings

This weeks reading continue our examination of implementation, design stategies, and exploration.

You need to:

1. Do something to learn about a “grammar of graphics” based tool or toolkit. Reading a paper about a grammar-based tool is optional.
2. Read a paper about an experimental toolkit.
3. Read a very short paper that helps describe how to think about statistics and exploration.

There will be questions about all three in Content Survey 2: Implementation and Methodology (due Fri, Oct 16).

Part 1: Learn about a Grammar-of-Graphiucs-Based Tool: You can learn about either Vega-Lite (or Altair, its Python bindings), or Tableau.

To learn about VegaLite (or Altair, it’s Python binding) go through the the first 2 “Chapters” of the UW Visualization Curriculum. (UW is the other UW, not us). I recommend that you watch the video first (its also linked in chapter 1). (Chapter 3 is optional, but recommended if you want to really understand or use the tool). Reading the technical paper for Vega-Lite gets at the ideas more directly.

Alternatively, learn about tableau (see Tableau Access for CS765). Here, you’re kindof on your own: but play with it enough (and read/watch enough tutorials) that you can make something by using the grammatical elements (identifying variables, tying them to encodings, using layouts, …).

Either way, the content survey asks you to describe what you did.

Part 2: Read a Research Paper: Read this paper. This isn’t a practical toolkit to use, but it is good food for thought, and an example of a modern technical paper to practice reading. It’s a best paper award winner. This can be a hard paper to read because it has a bunch of technical bits unrelated to visualization.

• modern Dominik Moritz, Chenglong Wang, Gregory Nelson, Halden Lin, Adam M. Smith, Bill Howe, Jeffrey Heer. Formalizing Visualization Design Knowledge as Constraints: Actionable and Extensible Models in Draco. IEEE Transactions on Visualization and Computer Graphics, (Proc InfoVis 2019), 25(1). (doi) (url)

A core question to think about as you read: what is different about this (Draco) than all the other toolkits you’ve read about?

Part 3: Read a Short Article on Statistics: This paper is less than 2 pages. And it’s about statistics (or data analysis), not visualization. But it calls to question a key point: what can we say about an analysis (or something we see in a visualization).

• core J. T. Leek and R. D. Peng. What is the question?. Science 347, 6228 (March 2015), 1314–1315. (doi) (web pdf)

My favorite way to think about this is in terms of the “three statistical tasks”: description, explanation, and prediction. I’ll explain that in class because there are no appropriate readings.

Week 2-2 Assignments

• Content Survey 2: Implementation and Methodology (due Fri, Oct 16)
• Design Warmup 2: Make Some Visualizations - Turned in on Canvas at Design Warmup 2: Make my visualizations (due Fri, Oct 16)

Week 3 (Module 2)

The main thing this week is the design exercise: you’ll need to make visualizations.

Week 2-3 Assignments

• Anonymous Survey 2: How is this working? (due Fri, Oct 23)
• Design Exercise 2: Stories from Life Expectancy - Turned in on Canvas at Design Exercise 2: Life Expectancy (stories) (due Fri, Oct 23)