What Is This Class and Why?

This posting explains the rationale for the class. It will help you understand my rationale for why I have designed the class the way that I have, and what you should expect from the semester.

I want to be upfront about what this class is. This class is different than most other CS classes. I want to get your expectations in the right place. If you’re expecting something else, you may be disappointed. And I think it helps you appreciate why I am teaching the way that I am teaching.

The is adapted from the prior versions (see for example the) 2021 version 2020 version 2019 version. You don’t need to read those - but I point this out so emphasize that this is not something I came to lightly. Over the (many) years I’ve taught visualization classes (and the even longer time I’ve worked in the field), I’ve come to some strong ideas about what and how to teach it.

The way I advertise the class (from old announcements):

This class is more about what pictures to make to understand data than how to make them. We will spend a lot of time understanding design principles. We will not spend lots of time talking about how to program visualizations, or how to use tools to make visualizations.

Or, to explain it another way:

Making visualizations isn’t hard. Making good visualizations is hard. So we need to understand what makes for a good visualization before we waste our time trying to make visualizations. This class is about understanding good visualizations.

So what is this class?

In this class, we will learn visualization principles - the basic ideas of how visualizations work. We’ll learn how to think about how visualizations are assembled from basic building blocks that will allow us to understand what they make easy to see. We’ll analyze a lot of examples. We’ll do lots of small exercises (often pen and paper) where we practice visualization problems to try out the principles. We’ll read, discuss, and critique a lot.

This class involves lectures, in-class design exercises (pen and paper), readings, on-line discussion, and some smaller “Design Challenges” (or mini-projects). If you think that a graduate CS class should be a big programming project and not much else, this class is not for you.

We won’t spend a lot of time talking about “computational issues” or implementation. There are “design challenges” where you will make visualizations (possibly by programming), but this isn’t the focus of the class.

We will not spend lots of time looking at specific visualization tools or implementation methods (e.g., libraries or frameworks). We will point you at some to help you learn about the concepts, but mastering a particular tool is not a learning goal of the class.

We do not let students “bring their own data” to class. This class isn’t just to help you solve the current visualization problem you have. It’s to teach you the principles you need to design a solution to problems in the future.

Why focus on “Visualization Principles” not implementation?

The principles of good visualization apply for everyone. For each person, the appropriate tools and development process may be different.

The principles of good visualization are constant and unchanging (although, our understanding of them is improving). The tools for creating visualizations change continually.

One of the premises of this class is that implementation is a detail (I explain this in the 1 - What Is Visualization and How do We Do It?) tutorial we’ll read in week 1. Implementation may be a big and important detail, but it is just a detail - it doesn’t matter if you don’t get the bigger picture right. One lesson in the class: don’t bother solving the wrong problem well. It’s a waste of time to make a great implementation of an inappropriate or ineffective design.

The skills for thinking about visualization principles (design, critique, task-oriented analysis, abstraction, …) are generally useful for many things. The skills for creating visualizations are pretty specific.

Over the years, I think I’ve learned to teach people the principles. For many of the implementation skills (e.g., web development), many of you either already know a lot more than me (i.e., you are up-to-date web developers) or aren’t at a place on the learning curve where a class like this will help (i.e., you need to learn basic web programming skills first).

Why focus on Basics/Foundations and not Fancy Stuff?

First, a lot of the best cutting edge research is building a better understanding of the foundations.

Second, is that really understanding the foundations is the basis for doing fancy stuff.

Third, and maybe most important, effectively using the basic stuff and foundations is usually what you need. Fancy stuff should be a last resort!

Visualization’s goal is to solve people’s problems. Sometimes, that requires inventing a novel and complicated visualization. Other times, it might mean applying some simple, off-the-shelf solution.

Here’s my favorite analogy. You go to the doctor’s office because you feel sick. The last thing you want to hear is “that’s a novel and interesting problem! we need to devise a novel treatment. let’s write a grant proposal and hire some research assistants…” No, you want to hear “I’ve seen that before. No problem. Take two aspirin and see me in the morning.”

As visualization practitioners, our goal is to be able to look at a problem and make those kinds of prescriptions. The foundations (e.g., task and data abstractions) are key here. It’s how we can say “I’ve seen that before” and get to “take two scatterplots and see me in the morning.”

A standard design (like a scatterplot or line chart) can be really effective in many situations. And, if a standard design can be effective there are lots of good reasons to prefer a standard design. For example, they are familiar to the viewer and you probably don’t need to reinvent the implementation. The key is to be able to identify when a standard design is effective and how to use it appropriately. You’ll need to make similar choices in inventing a new, fancy design.

How does the class work?

(this is a place where things are different than 2021)

As I write this (August, 2022), the University is operating in “business as usual” mode. We can debate how the COVID-19 pandemic should be affecting things, but as of right now, we’ll have class in person. Yes, you must come. If you do not intend to attend class meetings, please drop the class.

However, the experience of teaching in the past few years (where most of teaching was online) has really made me re-assess how class works. While I am really looking forward to more face-to-face contact with students, I also see pedagogical advantages in how the class ran online. Significantly, the work of adapting the class to online caused a lot of introspection. And it got me into the habit of surveying students to understand their experience. Which got me tinkering.

A lot of this class is about having students interact to learn together. This involves working together in groups. For this reason, we hold the class in a special “collaboration classroom” designed to support collaboration. Close, face-to-face interactions still feel a little weird given COVID, so we may need to adapt.

This class is organized around a steady pace of weekly assignments. I am de-emphasizing bigger projects (we will still have a mini-project at the end, but it will be more a series of small pieces). While I think this strategy is best, it does make for challenges in evaluation (especially since we are stuck with Canvas).

For the details of how class works, see the Policies page, especially the Rhythm page. But, briefly…

1. Each week there will be a non-trivial amount of reading (which includes “watching” videos as well as online resources). I expect people to try to learn as much as possible from this - even though it’s hard for me to measure (I will not give exams).
2. Each week, class will meet on Monday and Wednesday. Class periods will be a mix of traditional lectures (professor monologues), in-class collaborative exercises, small-group and whole-group discussions, … I have been trying over the years to reduce the amount of monologue to make space for the more collaborative elements. We will try to keep track of participation.
3. Each week, there will be a few “regular” online class activities. For this year, I am going to try to de-emphasize online discussion because it doesn’t work for everyone (and often feels forced). There will be a “survey” each week that will help you self-assess whether you are learning the material (and we may look at it to evaluate you).
4. We will have a number of exercises (homeworks / mini-projects) that will happen regularly (hopefully with a standard weekly pace). Rather than big projects, we’ll have a sequence of small things that may (or may not) add up to something bigger.

This class is, admittedly, not for everyone

This class will teach you how to design good visualizations, and will teach you a little about the choices you have in how to make them. If you learn how to use some tools for making visualizations (Tableau, D3, R, matplotlib, …) you will know what to make with those tools!

There are good resources for learning about specific tools. And in class, you may meet others who are also trying to learn these tools as well.

The focus on the non-technical elements (design, design methodologies, …) makes this different than the standard CS class.

If you dislike classes where you have to attend class and do lots of small regular assignments each week, this class may not be for you.

But, I don’t care about general principles – I just want to visualize my data

Sorry, we generally don’t let students “bring their own data” to class, for a number of reasons.

The principles you will learn will help you work with your own data – but for learning in class, it’s best that we work on data that everyone has access to, and that we believe is the right level of challenge. If we’re not going to program, what are we going to do?

You can look at the course web to get a sense of what the class will be. If the course web for this year isn’t completely together yet (I am writing this page first), you can look at last year’s class. This year’s class will be an adaptation in many ways, but the basic topics will be the same.

You can look at the Schedule to get a sense of what we’ll do in class. You can also look at the 1 - What Is Visualization and How do We Do It? page (required reading in the first week) which summarizes the course content and my philosophy. You can also look at last year’s course web, since this year will be an adjustment, not a complete change.

In terms of what we’ll do this semester…

• We’ll do a bunch of reading and discussing to understand principles.
• We’ll focus on learning critique skills to help us learn by analyzing visualizations.
• We’ll spend a lot of time examining examples to understand why they work (and why they don’t). This will include spending time looking for examples to see how visualization is out there in the world.
• We’ll spend time learning the building blocks that visualizations are built from.
• We’ll spend time learning about visual perception and how it influences visualization design.
• We’ll do some design exercises to try to appreciate how those principles get put into practice.
• We’ll look at some specialized techniques and designs for dealing with particularly tricky kinds of data.
• We’ll do some larger design challenges to practice applying the principles.

You’ll see that this aligns pretty much exactly the with the topics of the class, and the way that the class is organized (see Parts of Class and Schedule.

Learning Goals

Moved to the Learning Goals page.