What is this course and why?

What is this class and why? (or, “will you like this class?”)

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.

From the announcement:

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 (usually 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.

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 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.
But, I really want to learn about (programming, using Tableau, …)!

This class is, admittedly, not for everyone.

This class will teach you how to design good visualizations, and will teach you a little about 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.

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?

Because this year’s schedule isn’t together yet, I recommend that you look at the course web for the last offering (especially the schedule), it will give you a good sense of the topics we’ll cover. This year some things will change, but the basic structure and main content will be the same. You may also want to look at the “How to Visualize” post which summarizes the course content and my philosophy.

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.

Learning Goals

A few years ago, I went back to try to formally state the learning goals for this class. Initially, I thought this was just University paperwork, but after a while, I appreciated it as a good way to think what the class is really about and why we are doing the things we are doing.

From the Official University Syllabus (phrased as outcomes – these are high level and a bit abstract, but still relevant):

1. Students will understand the potential of effective data visualization.
2. Students will understand the key principles for the design of effective visualizations.
3. Students will be able to design and evaluate data visualizations for a variety of tasks.
4. Students will understand the relevant basics of visual perception and its role in design.
5. Students will understand some standard visualization methods and their applicability, and have exposure to standard kinds of data interpretation problems and their standard solutions,
6. Students will gain exposure and practice with some of the skills required to be a researcher and practitioner in the field of Visualization.

Making this more concrete, we will teach students to:

1. Understand what visualization is in the broad sense, with an emphasis on task and effectiveness.
2. Appreciate the potential for visualization, what it is good for (and not).
3. Perform design critique, especially for visualizations, but as a general skill.
4. Understand basic design process, and use it for visualization.
5. Appreciate visualization design in terms of its building blocks, and use this approach to design, redesign, and evaluate visualizations.
6. Understand common challenges encountered in creating visualizations, and have a sense of the existing strategies for addressing them.
7. Apply common design principles, and intuitions of how the pieces can be fit together, to design visualizations.
8. Appreciate the approaches to implementation, and select among the choices.
9. Appreciate how the ideas of visualization are used in practice.
10. Have a sense of what visualization research is.