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.
The is adapted from the 2020 version which was adapted from the 2019 version, which is adapted from earlier versions. 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 10 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.
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 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 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, …)!
How does the class work?
This is a little up in the air - right now, the University is telling me that I should “teach in person as normal.” But, aside from the pandemic situation, I actually learned a lot from the experience of re-designing the class to work online. So, while I am really looking forward to more face-to-face contact with students, I also see pedagogical advantages in how the class ran last year.
As I type this (August, 2021), I have been asked not to convert this class to online. But for now, you should plan on their being class meetings which will combine some “traditional lectures” with in-class discussion and design activities. You will need to bring art supplies to class. I am concerned that in-person design activities (people working together closely in small groups) may not be a good strategy (both for safety, but also because these things actually work better online).
Last year, long before class started, I wrote a page explaining to students how I intended to run class. This was July 2020. Looking back at it, I think it is useful because it discusses the decisions I made in the past - it describes the historical “in person” class design, and its upsides and downsides. Ironically, this might be the best way for you to understand how the in person version of the class worked. With that caveat, here is the 2020 link to the online rationale.
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?
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 the content is pretty similar.
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 Parts of Class
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):
- Students will understand the potential of effective data visualization.
- Students will understand the key principles for the design of effective visualizations.
- Students will be able to design and evaluate data visualizations for a variety of tasks.
- Students will understand the relevant basics of visual perception and its role in design.
- Students will understand some standard visualization methods and their applicability, and have exposure to standard kinds of data interpretation problems and their standard solutions,
- 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:
- Understand what visualization is in the broad sense, with an emphasis on task and effectiveness.
- Appreciate the potential for visualization, what it is good for (and not).
- Perform design critique, especially for visualizations, but as a general skill.
- Understand basic design process, and use it for visualization.
- Appreciate visualization design in terms of its building blocks, and use this approach to design, redesign, and evaluate visualizations.
- Understand common challenges encountered in creating visualizations, and have a sense of the existing strategies for addressing them.
- Apply common design principles, and intuitions of how the pieces can be fit together, to design visualizations.
- Appreciate the approaches to implementation, and select among the choices.
- Appreciate how the ideas of visualization are used in practice.
- Have a sense of what visualization research is.