Yes, I am aware that I haven’t given you much information about specific grades for this class. I apologize. It’s a challenge.

Earlier posts should have given you a pretty strong sense of how we will grade.

But now as we near the end, I can be a little more specific…

The exact numbers below might be tuned a little – but probably not much. If you’re curious, by the standards below the median grade for both the 638 and 838 sections is an A, and in general, the grades in this class are much higher than normal. I am OK with that, since I am quite impressed with the work that people have done this semester. And, I appreciate that people have put up with the experimental nature of the class, and have had patience with our inability to be clear about grading.

The components of your grade:

• Online discussions (including readings and 838-only assingments). There will be about 20 of these total (more for 838 students).
• Seek and Finds. There should be 13 of these total. The last 4 will be graded a little more carefully than the first 9.
• Two design assignments and one data assignment.
• In-class assignments. There will be about a dozen of these total by the end.

There are two independent questions: how will we evaluate each part, and how will we combine these evaluations to form a final grade.

If you want to know how your various counts stand, you can ask Alper.

Considering the parts

Each of the parts is different.

The in-class assignments are really a proxy for your general attendance and engagement in class. It’s more than just showing up (since if you show up and just look at Facebook, it might be worse than not showing up). We’ll use the in-class assignments as a proxy measurement for general attendance/engagement. If you did the ICEs, then you were there and engaged. There’s also a sampling issue: we only check this a small number of times. (and the measurement is imprecise).

We will only score ICEs check/no-check.

We’ll use the count of number you missed as a way of guessing at your overall class attendance. Say you missed N ICEs. At best, you missed this many classes total. Worst case, this is representative of your attendance in general (the percentage is about the same). (the real worst case is that these are the only classes you came to – but we’re more optimistic than that). Note: if we catch you cheating (e.g. having someone turn in something with your name on to try and get counted when you weren’t there), that is academic misconduct, and we will act accordingly.

• If you missed more than 3 ICEs – you cannot get an A for the class.
• If you missed more than 5 ICEs – your grade is reduced by 1/2 step.
• If you missed more than 8 ICEs – your grade is reduced by a whole step.

The first 9 seek-and-finds (before break) were not graded consistently, so we’ll treat them check/no-check. In fact, one of them wasn’t even required. The later seek-and-finds will have an actual grading rubric, so we’ll count them as discussion assignments.

• If you missed more than 2 seek and finds – you cannot get an A for the class.
• If you missed more than 3 seek and finds – your grade is reduced by 1/2 step.
• If you missed more than 6 seek and finds – your grade is reduced by a whole step.

Note: the seek and finds / ICEs are penalties that get applied after we figure out what your grade would be.

Discussions are the main thing we have to grade. However, the scoring system doesn’t give us very much precision (especially at the high end).

To figure out your discussion grade, we’ll drop the lowest 2 scores (so if you missed two, it doesn’t matter). And then quantize people as follows:

• Almost always 4 or above – either an A or an AB
• Usually 4 or above, almost always 3 or above – possibly an A (unlikely), probably an AB
• Sometimes 4 or above, almost always 3 or above – AB or B
• Usually a 3 or above – B
• Median below 3 – less than a B

Note that there is some wiggle room in there: “almost always” probably means like 80% of the time or more, but we aren’t specific. “Usually” could mean the median is at the level, but again, we give ourselves wiggle room. This allows us to include factors like our subjective impressions, what level you are at (638/838).

Also, note that these gives a grade range: to decide where your grade is within the range, we will look more closely at your work. Remember, we didn’t consistently give 5s (although, if you did get 5s, that’s a clue that we’re likely to think highly on a second pass). We won’t read everything – we’ll do a little sampling, and try to decide where in the grade range you stand.

We’ll take your level (638/838) into account when figuring this grade. If you’re a 638 student, you’ll probably score at the high end of the range.

The Design/Data assignments are scored on a 20 point scale, and a 10 point scale for the quality of the critiques. There will be a scale for each. I will make a base scale, and we will adjust downwards if the grading was harsher (that is, if everyone gets an A great, but at a minimum 25% of the people should get As).

Your “letter grade” will be 1/2 of the discussion grade, 1/4 of the design data grade, and 1/4 of whichever you did better at.

This class is an experiment. I’ve never done anything like it.

Here are some more thoughts on discussions. Hopefully, you’ve seen my discussion of discussion (in fact, read that first if you haven’t).

Some people have asked (to Alper, not to me directly), some variant of:

• How do I participate in a discussion?
• How do you evaluate a discussion?
• What if I have nothing to say?
• What do I need to get an A?

If you think you’re panicked about how you will be evaluated in this class, we’re even more panicked about how we will be doing the evaluation. Let’s try to make it easier on each other.

If you haven’t seen the course philosophy on grading, you might want to look at that.

It can be intimidating to join in a discussion. There is a diverse range of people in this class. There might be someone who knows more, who has thought about the topic more deeply, is a more eloquent writer, … You might have a great idea, but someone else beat you to it. You might have an idea that you’re unsure of, or that you don’t know how to express clearly. You might not understand what another person is talking about, or might misinterpret what they said.

And then, there’s this issue that these discussions are the primary data we have for evaluating your performance in class. So, you might not want to say things that are wrong.

Ideally, we can make the discussions be a “safe” place where people can express their ideas without being intimidated. Where people will support each other in learning. This requires all the participants to be polite, to help each other, to be supportive of each other – both giving and receiving. As far as we can see, people are doing a good job of that. We can’t police everything in real time, but it doesn’t seem like we need to. (if someone does something you think is inappropriate, please inform Alper and I immediately).

As far as grading: what we care about is that you participate effectively, and show some basic understanding. The discussions are set up (or we try to set them up) so that you can achieve the demonstration of basic understanding in your initial post. The discussion part can be hard: sometimes, there isn’t anything to add. In an in-person discussion, everyone can nod in agreement: on Canvas, a dozen people making “I agree” posts can get tiring, and dilute the content. Although, it’s a nice gesture to be supportive. There’s a fine balance, and hopefully it will work itself out (in some systems, they have mechanism for this).

So, here are some ground rules:

1. It’s OK to disagree, if you do it respectfully. If there was a question with a clear right answer, you wouldn’t need a discussion.
2. It’s good to ask questions if you don’t understand. This can be a great way to give people feedback on how they express their ideas. It’s best if you are specific, and critical that you are respectful. You can even ask questions about the content.
3. Be tolerant of others: the responses are often “off-the=cuff” – written hastily, sometimes in someone’s non-native language, without tons of time to think everything through.
4. If you don’t have anything to add, you don’t necessarily need to add it. Although, it can be nice to be supportive – especially if you can add a little, and be specific. Saying “I agree, and you explained it well” is a nice complement – but might not add too much to the conversation.
   Trying to add: “I agree, but I might have phrased it like X” might help everyone understand by giving a new perspective, and is a vote on the idea, but can be a subtle put down that you think you can express it better, and that you want to claim some “ownership” of the idea. For a class discussion, I think it’s more OK than in other settings. Especially since there is no way to enforce fairness in turn taking (some people will respond quicker)
5. For evaluation, in the original post, we are mainly looking for evidence that you did the required assignment (reading or design), and have given it some thought. It’s less about right answers (again, the interesting questions don’t have obvious right/wrong).
   Beyond the original post, we are mainly looking for evidence that you are thinking about things.
6. We understand that the opportunity to participate in discussion involves an element of luck. If no one says anything worth responding to, you can’t make a good response! If someone posted your idea before you, it’s hard to sound original. Hopefully, things are structured such that there will be enough opportunities.
7. If you say what you got out of a reading, or your opinion, it is correct (it is true that it is your opinion). We can try to (constructively) change your opinion, or help you get more out of a reading.

Trying to “grade” discussion is challenging, subjective, and possibly a fools errand. That’s why we’re more looking for consistency over the whole, and only “scoring” in broad buckets. And, we might need to replan if need be.

I think I’ve said it enough, but we’re not going to talk about implementation much, and I am not going to force people to do any programming. However, some of you might want to do it, and some of you might want to learn more about it.

(by the way, if you are interested in D3, read my discussion about learning it).

There are a bunch of basic computer graphics concepts that are probably useful in this class. Some of you learned these by taking a graphics class, some of you might find you actually know them. Part of the problem is they are so ingrained in the way that I think that I forget that

Here are some possibly useful tutorials from 559 (the Graphics class I taught last semester): (complete list):

• Points, Vectors and Coordinate Systems (why are points and vectors different?) – an attempt to get some linear algebra concepts across, even if you are not used to thinking in linear algebra. In class, it’s useful to think in terms of spaces (in the mathematical sense) – and these linear algebra intuitions are useful. This tutorial is useful if you know the math and want to get the intuitions. You can see if it helps with the intuitions without the math.
• Image-based graphics vs. Object-based graphics – useful to understand what kinds of ways we make pictures with computers (like why is an SVG image different than an PNG or JPG)
• What is a Pixel? (and what is a point sample) – this will get a little deeper on the “SVG vs PNG,JPG,GIF” question – but maybe deeper than you want to know.
• Some initial practical answers to harder questions – this is a dose of practical info about color to hold you over until we really learn about it.

If you want to learn about SVG (useful for making pictures that work in a web browser), I made these for 559 students to get them started – once you are on the right path, there are a lot of resources on the web.

• SVG:1 – Getting started with SVG
• SVG:2 Coordinate Systems
• SVG3: Manipulating Primitives
• SVG4: Groups, Transforms, Re-Use, and Hierarchies
• SVG5: More Transforms and Composition
• SVG6: Paths and Beziers

This is some background on why I am making the course the way it is. It hopefully explains why the policies are the way they are, and gives you a sense of “the spirit of the law.”

My goal in this class is to provide you with a set of experiences that will help you develop you understanding of, and abilities in, Data Visualization (and related broader context – like being a good scientist).

My goal is: Everything I ask you to do is because I believe that the experience of doing it will benefit you (and be worth the effort you to put in).

Ideally, there is no “busywork” – everything you do is because I believe that you (or at least the majority of students) will get something out of the experience. For all activities, I will try to help you understand why you are doing it (stating the objectices) – although sometimes I may not have the time to state them, and sometimes, telling you the outcome ahead of time might change how you view the assignment.

Over the semester, I may need to make some concessions to the “no-busywork” goal, as we have other constraints.

• We need to do things to make sure the class runs smoothly.
• We need to do things to make the class practical.
• We need to be able to assess that you did learn enough (to give you credit) and how well/much you learned (to give you a grade). The need to certify/assess is a bit of a pain, but its part of the University’s job.
• I am experimenting with what activities will actually create these learning experiences.

These things aren’t necessarily contrary to the primary goal (the student’s learning). For example, if the class doesn’t run smoothly, it will be harder for you to have the experiences that you will learn from. Or, an experimental in-class design exercise might teach you a ton, or turn out to flop (we need to take those risks).

In a smaller class, fewer concessions to the experiential goals need to be made: we can have discussions, and the course staff can get to know everyone well enough that we can do fair evaluation subjectively. I’ve run lots of successful smaller classes.

This semester, we can’t do that. We can’t have discussions with 90 people. (if everyone had 1 minute, we wouldn’t fit in a class period). And I am trying to experiment with how I can create the same experiences we provide in the smaller class to a bigger class. Bear with me as I experiment. Some of this involves using technology which has a learning curve for both of us, and will require you to do many things “online” (typing them in rather than just talking about them).

Also, I am questioning the effectiveness of the traditional “monologue lecture” class style. I believe that people can get a lot out of watching me lecture for 75 minutes. But I am not sure this is the most effective use of student time.

So, that’s a long winded way of saying…

1. The activities in this class really are meant to give you the right learning experiences.
2. I really am trying to minimize the busywork, so we can do #1
3. Please be patient with the experiments (especially the technology)
4. Yes, some of the technology will make extra work for you – but hopefully it will pay off by making things run more smoothly
5. Yes, I really think you should do all of the class activities.

Grading, Evaluation

Having to assign grades is one of the least enjoyable parts of teaching for me. I would like to educate students – not judge or certify or assess.

My goal is to assess your command of the material. I will try very hard not to assess your unrelated skills (for example, your artistic skill). Unfortunately, directly measuring your command of the material is hard.

For many (most?) class activities, it is difficult to assess how well you did it. So we will mainly keep track of “did you do it”. (e.g. most things will be more or less graded “check/no check”). This isn’t just a case of the famous adage “80% of success is showing up” (see http://quoteinvestigator.com/2013/06/10/showing-up/ for a discussion of where it came from). The logic is that we think these activities are important enough that just by doing them, you can’t help but get something out of them.

This means you really do need to do all the assignments and in-class activities because we’re counting! And it means you’ll need to bear with the technology we use to keep track of these things.

This means you need to show up to class! Because if you don’t, you’ll miss out on in-class activities. And you can’t make some things up – if you miss a class experience/activity, you’ve missed it.

(this is a follow on to the “How to do Vis” post that explains why we aren’t focusing on implementation).

D3 is a Javascript toolkit that helps with making web-based visualizations. It is quite popular and gets used a lot. If you don’t know what it is, don’t worry – the rest of this posting might not make much sense.

In this class, we will not teach you to use D3. At a high level, we won’t be “teaching” you about using any particular toolkit – we’re emphasizing design, not implementation. But D3 is a specific challenge that is worth mentioning.

If you want to learn D3, you have made a good choice: it is a good way to build mark-based visualizations that run in the web browser. And building stuff to run in the web browser is the right choice: it means your stuff is portable, easily shareable, embeddable in other content, and likely to remain compatible if platforms evolve (since legacy web support is important).

However, there is a cost: part of what makes D3 great is also its biggest curse. D3 is tightly integrated with all kinds of other web stuff, so it fits in well. But that means you need to know all that web stuff in order to use it. That means its hard to learn, unless you know a lot of other stuff first.  At first I thought it was just that I couldn’t wrap myself around the modern idioms, but then I saw a number of students get stumped the same ways that I did (or worse).

We will learn about D3 in class. We’ll learn about its concepts, since they are interesting and a nice way to think about how to do implementation. We’ll try to understand where its kind of approach (mark manipulation) makes sense as a strategy. But, we won’t require people to actually try it – since actually trying it requires you to have a lot of knowledge first.

If you want to learn D3, I recommend the following path. Resist the temptation to skip to step 5. Trust me.

1. Know a little about HTML, and how HTML gets implemented in the browser. You should be comfortable with the concept of the DOM. Knowing about CSS is handy, but not essential. This part is easy, since you don’t need to know much. And you can’t do #2 (Javascript) without it. (well, you can put javascript right into SVG files, but that’s another story)
2. Learn Javascript. Javascript is an unusual language – it evolved rather than was designed, and the forces of necessity (it’s in so many web browsers that things can’t change) cause it to become an even odder language. The better you understand its unusualness, the better the chance you have with #3. Fortunately, the tools for Javascript have gotten much better (most web browsers have good debuggers). But even before that, I was able to get a class of CS undergrads to teach themselves Javascript and do amazing things with it (see the 2012 games class and the 2011 games class). My 2012 Javascript resources page is probably woefully out of date – but I still would recommend “Javascript the Good Parts.”
3. Learn the selector-based programming idiom (e.g. get exposure to JQuery). Not only is Javascript a weird language, but people use it in weird ways. Some of these “idioms” are very pervasive. Selection-based programming is one that took me a bit to catch on to – since I tried to use it in D3 before I understood what it was really doing. I recommend figuring it out before you try D3.
4. Learn SVG. SVG is the graphics infrastructure you’ll probably use with D3. Certainly, all of the tutorials will use it. SVG isn’t hard – in fact, I use it for the introductory assignments in the graphics class. There are some tutorials there (see “Getting Started with SVG”, but you might want to look for the tutorials before and after it as well).
5. Now, find a tutorial on D3 and go through it. Most likely, it will work through an example that uses everything above. If you skipped to this step, you might get stumped by things like the selection idiom.
6. Once you’ve been through a tutorial or two, try to take an example (there are lots – because the D3 community likes to share examples) and make it do something slightly different. This is a good way to figure out how the examples work.
7. Try to make something simple yourself. You will find yourself going to the web to look things up a lot.

I think that learning D3 is worth it. People build really nice things with it. And having stuff run in the browser is a total win, if it’s practical for what you’re doing. If it’s not practical (you need to consider large datasets, or complex computations as part of the visualization process, or …), it might even be worth it to think of a client-server system where some back-end does the crunching and the front end runs in the browser (this is the preferred way to do things in our research group these days).

Note that D3 is probably not the thing to use if you aren’t going to do SVG-based (2D object-oriented drawing) graphics. If you’re doing images, or volumes, or 3D, etc. you might want something else. Also, if you want something standard (e.g. just a scatterplot), you probably want something a little higher level (D3 will help you draw the scatterplot, but the Google Charts API will just make one for you). Also, if you want to do something specialized, there might be a specialized tool for it.

What about things other than D3?

I single out D3 because its the one that most people ask about. It’s also really common. And, it’s upsides (working well in the browser, and being extremely general) make it worth the steep learning curve.

Generally, in other environments (than Javascript in the browser), I’ve tended not to use visualization specific toolkits. Instead I use the basic graphics and UI functions provided. So I don’t have much experience with vis-specific toolkits. (there will be an upcoming post on what I use myself – and why it might not tell you much).  As I mentioned, there are a host of toolkits for doing more specialized things – I just can’t say much about them.

There is one that I should mention, since it is probably the granddaddy of them all. The visualization toolkit VTK. VTK has been around a long time. Its focus is on “scientific” visualization (3D, geometry, large data manipulation, …). It’s a big beast. It has evolved over the past 20+ years. The project was started by some Vis pioneers, and has grown considerably over the decades. It is free and open source, but supported by a company. So many big projects rely on it, that the project gets sufficient support.

Ironically, D3 and VTK have the opposite problems that cause them to be hard to get started with. With D3, there’s so much emphasis on fitting in well with all of the other pieces and standards, that if you don’t understand them all, you can’t do anything. With VTK, they went to the extreme of doing everything themselves – including having their own build system. Which meant until you figured out a zillion pieces, you couldn’t do anything.

My experience with VTK is (at least) 12 years out of date. I just haven’t had a project where I needed to do the kinds of stuff its good at. If you need to work with a standard “scientific” data type, and/or try a standard “scientific visualizaton” algorithm on it, its probably a good place to start. Or, try to find an application that has already been built on top of it.

Here it is: the whole class distilled into a single Blog posting! Maybe you don’t need to take the class.

Over the course of the semester, we’ll get lots of perspectives of how different people tell you to do visualization. Here’s an attempt to write down my perspective. You’ll see that it is well aligned with Munzner (which is part of the reason I like her book so much). In particular, when you learn the nested evaluation model in class, you’ll see a strong parallel here.

This is what we (in my group) try to do when we work on trying to create visualizations (or, to be more precise, help solve data understanding problems.

There are four elements to visualization:

1. Task
2. Data
3. Design
4. Implementation

The challenge is that you can’t do a good job with one of these, unless you’ve done the levels above. Hopefully this explains the structure of the class.

I was going to title this posting “All I ever really needed to know (to do Visualization) I (could have) learned in Munzner’s Nested Model Paper” –  as a play on the title of the book “All I Ever Really Needed to Know I Learned in Kindergarten,” but I haven’t actually read that book, and the humor is lost if you haven’t heard of it.

The core is the TASK

Visualizations help someone do something for some reason. (who, what why).

The better that you understand what the visualization is trying to achieve (what will it help the person do), the more likely you will come up with a good solution. In the end, everything serves the tasks.

Note the plural: you may have a set of tasks. Often, there isn’t just one at a time. There are a set of things that a set of someones may want to do for a set of reasons.  And maybe your solution will address many of these.

I was going to say “it starts with the tasks,” but sometimes you start someplace else (like you have some data and say “I’d like to do something with it” – but even then, I would probably say you have a task: figure out what the right questions to ask are!). However, in those cases, it’s really important to remember that task is key: the sooner you get to “what is this thing going to do for someone,” the better off you are.

This is also not to say that you need to fully understand the task at the beginning. Sometimes, your understanding of the task is hazy, or changes as you learn more (from later stages).

Task is an informal, fuzzy notion. It doesn’t always get explicitly written down or defined. But the clearer you are about it, the better off everything else will be. You can’t succeed unless you have something to succeed at.

One other detail on task: there is a range of kinds of tasks. There are abstract tasks and concrete application tasks. This is actually a spectrum/continuum.

While task is the most central thing, it’s also hard to talk about. We lack good, rigorous ways to talk about it.  For the longest time, it meant that it didn’t get discussed enough (in the literature, in my class, in my work, …). The fact that it is hard shouldn’t get in the way of us trying to get better at thinking about it. We particularly lack good ways to talk about different levels of task abstraction.

Where I start…

When I talk to a new (potential) domain collaborator, I always start with the the question “tell me about your science.” I want to know the big picture (the why) – because without it, it’s hard to have context.

My first goal is to identify the problem that needs to be solved – it won’t help anyone if we solve the wrong problem.

Usually people come thinking they want specific help – they want to start with the data, or worse, with the way they are looking at their data (can you make a better chart for me? not without understanding what you are trying to do, so I know what “better” means!) We will get to that, but I think its important to identify the task.

I’ll stress this: if you want to be a visualization scientist (or more generally, a data scientist or computer scientist), one of the best skills you can have is to be able to help people identify their problems. I think it’s hard for people to identify their problems. Part of this is that people get so caught up in the details, that they lose sight of the big picture. Or that they are so set in how they do things that they lose the ability to imagine alternatives.

And, as computer scientists (and/or mathematicians), we have a secret weapon: abstraction. This is something that we value/stress much more than other disciplines. For this task phase of visualization, abstraction is a key tool. If we can recognize the abstract task for which the real problem is an instance of, the path to solving it becomes much clearer.

We should also remember, that our 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 task identification and abstraction is 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.”

Where we’ll finish…

Ultimately, you’re quest is to make a good visualization, not just any visualization. Generally, a big part of this will be “did you solve the problem” which of course means that you need to know what the problem was (e.g. the task).

It turns out the idea of “is it good” will be a challenging question – there are many different ways to think about whether or not a visualization is good, and many ways to assess it. But a lot turns out to come back to “did it solve the problem.”

It’s worth mentioning that the whole line of thinking here is based on the “nested model” which is a discussion of evaluation.

Sometimes, the best visualization isn’t a visualization at all: you might be able to come up with a solution to the problem that doesn’t require a visualization. Understanding when and why to use visualization as a strategy for solving data (or understanding) problems is a key part of being good at doing vis.

You need to have / know your data

We’ll see lots of examples of visualizations that don’t really show lots of data. However, even there, the data is important and may be hidden.

There are lots of challenges with data. It’s a lot of work to obtain it, wrangle it, validate it, store it, keep track of it, …

For our purposes, the important part is to understand what is and isn’t in it, so that we can see how it can be used to address the task. Or how the form of the data, or factors of it, may change the task (or create new, intermediate tasks).

One way to think of visualization is that its the process of applying data to address a task.

Generally, the data is there to do something – it’s part of the bigger problem. Rarely, is it an end unto itself. If you find yourself saying “I want to understand my data” – ask yourself why. Generally, data is in service of a goal. Keeping that ultimate goal in mind (the real task) is a good idea – even though you might solve a “data task” (which usually corresponds to an abstract task).

For example, the common data question “I want to see if my data is noisy” is a good example of an abstract task. Probably, you want to know if the data is noisy because you want to do something with it (or maybe because the source of noise might be interesting for your ultimate question).

A Design Addresses the Problem

One you know your task and your data, you can try to design a solution. I say “design” to explicitly separate the act of coming up with the idea and actually building it (implementation). Design is the act of making conscious choices to solve a problem. (Defining design is a whole philosophical debate – but that definition is one I like, and will work with for the moment)

In terms of the class, a big part of what we’ll do is focus on design. What are the choices you can make, and how can you make good choices.

There are a few key elements to a visualization design:

• Transformation – changing the data to a form that is better suited to what you want to do.
• Layout – figuring out where to put things “in space” (where space is usually the 2D of the page/screen)
• Encoding – figuring out what things to put in that layout
• Interaction – how you might change one of the other elements in response to what the viewer is doing

I find this list to be a useful way to organize the larger list of more specific things you might do. Most things fit into one category or another. I won’t waste time arguing this is the best categorization – but its good enough to give you a sense of the kinds of things that you can think about.

In the class, we’ll spend a lot of time thinking about design. We’ll pick apart existing designs to understand how they work. We’ll learn foundations, like perception, that will help us come up with and evaluate designs. We’ll try to give ourselves a library of standard designs to try out on problems we encounter and to modify as necessary. We’ll practice making designs and assessing how well they address problems.

Implementation

Actually creating the design is the last part.

If you were thinking “this is a CS class, we should focus on implementation,” you will be disappointed. As I’ve said, this class is more about how to figure out what the right picture to make is (e.g. the design) than how to make it.

In the ideal world, you can think about implementation last – it’s an afterthought. In practice, the constraints of having to implement things will probably influence the kinds of designs you will want to consider. A design becomes less attractive if its too hard to build. In practice, there’s often a tradeoff between the practical issues of implementation and having the best design.

Even within implementation, there is a spectrum of levels. I like to think of this as “fidelity of prototypes.” In a sense, you can think of a back-of-the-napkin sketch as an implementation of a design. Most likely an incomplete, non-final one, but an concrete instantiation. It might be a good enough implementation that you can evaluate your design and decide if you want to pursue the design further (and make a higher-fidelity prototype). If you’re lucky, a crude prototype might just solve the actual problem.

One thing I like to stress is the importance of prototyping to explore designs. It’s best to try out lots of ideas, and see if you can figure out their problems before investing a lot in implementing them. Good “Designers” (graphic designers, industrial designers, …) usually like to explore an entire space of designs – by using very crude “implementations” (e.g. sketches).

Data analysis tools – things like Excel (yes, excel will turn out to be my favorite visualization tools) or Tableau or … – often let you prototype lots of different things with your data. This “playing” with data – re-ordering it, making various kinds of pictures with it, looking at it all kinds of different ways – is actually a form of rapid prototyping. You can explore a lot of designs easily – often to decide that they don’t solve your problem – but sometimes to see that some of the simple elements actually can help. This “playing with data” (if you can do it) is a lot like sketching a lot of visual designs.

Having a good toolbox so that you can implement your designs is useful. If you don’t have one, you will be limited in what designs you can explore, and won’t be able to choose designs that you can’t realize (that’s not quite true: if you can come up with a great design, you may be able to get someone else to implement it). Part of my premise for this class (or at least this instantiation of it) is that we can all have different toolboxes – some students might be wizard programmers, some might be fabulous artists – but we all can have some common basic tools (e.g. sketching), and we can all explore designs using out respective toolboxes.

Now, if you’re saying “but I want visualization to be about writing fancy programs using complex data analysis methods and algorithms and spiffy programming things …” let me give you a bit of caution.

Building a custom visualization solution by programming should be a last resort. You should really believe that your problem cannot be solved by some easier method. Going back to the medical analogy, writing a program for a new design is like inventing a completely new (and therefore untested) treatment. Yes, if your patient has a mysterious disease and is going to die you want to take these drastic measures. Or, you might do an experiment if you believe that you can afford the risk on this patient in order to learn something to save the next ones (this is the excuse we use as researchers).

That said, all too often there are other factors that make us want to take the extreme measure. Sometimes, we just want to practice our inventive skills. Sometimes our “customers” think they want to have something novel (don’t make it look too easy!). Sometimes we really want to try out some implementation idea, or show off some challenging design idea. And sometimes, it might just be easier to re-implement a standard design than to figure out how to make an “easy” tool do what we want. (you’d be amazed how often I’ve found myself writing Python code for scatterplots because I wasn’t in the mood to wrestle with Excel). Sometimes, it’s hard to find a decent “easy” tool for something that should be easy (like graph layout).

But I really want to learn about some of the implementation things (D3, SVG, Python, Tableau, …) – I’ll have some postings soon that will help. Note that in class we will learn about these things, but we won’t necessarily learn to use them (again, that will be explained in a future post).

But is looking at a table in Excel Visualization?

Two answers:

Yes! You can often solve hard data understanding problems using visual methods in excel. And that’s even before we get to fancy charts (which it can do some of). And understanding what you can and can’t do this way is important.

No! Learning to use Excel to analyze data is not what this class is about.

However, a lot of the elements of visualization designs can be tried out and appreciated. And you can see how simple problems can often have simple solutions.

So, we can look at how having data in a table can be OK sometimes since it can solve some problems. And we can see how we can apply those 4 design elements: transformation (computing derived quantities), layout (ordering data in different ways), and encodings (highlighting different values). Even a little interaction (switching between the different things). Yes, you can experience the core ideas in visualization with a table in excel.

And then we can move on to more complicated examples.

 

What if I told you that the most influential books in the field of Visualization were self-published books written by a guy with no formal training in Visualization, Perception, or Design. A political scientist was forced to teach statistics to journalists, and in the process decided to think about visualization from an art historian’s point of view. Supposedly, no one would publish his book at first, so he took out a mortgage on his house and self-published it. Yes, this is Edward Tufte. If you’re not familiar with him, there’s an interesting article here, although, it is clearly written by a Tufte believer.

There is no denying that Tufte is an important figure in Visualization. He has strong (extreme?) views, that are not necessarily based on evidence or empiricism. They are not always right. For example, his assertions about the importance of minimalism are a huge over-simplification (although, if you understand the historical context of them, you can see the point he was trying to make). He fails to acknowledge that there are many who do similar things to what he does, but in a more rigorous (and scientifically justified) way.

Tufte (and his books) are kind of like religious documents. To a believer, they are true facts. Suggesting otherwise is heresy. But to most people, they are best interpreted as historical fiction that is designed to make a worthwhile point. And no one can deny that it is influential.

Tufte’s books are wonderful. They are artistically beautiful: well designed, and full of nice examples. View them as an art history lesson, showing you historical examples of the art (of visualization) . View his writings as provocations: designed to challenge you to think, not to be taken literally.

If you are going to work in Visualization, you will probably want to have a set of Tufte books on your shelf. In fact, if you’re a student, you can take Tufte’s one day seminar at a discount and get a set of books. (note: I have not seen a Tufte one day seminar, but I have sent students to see them – I do own the books). (see update below)

For this class, it is valuable to read some Tufte. Thanks to the concept of academic fair use, we can provide you with a chapter or two from some of his books as part of the course reader. Sadly, looking at a scan of the book belies the beauty of the book design. So, hopefully, seeing the chapters will inspire you to look at the whole books.

 Update: It seems that Tufte is selling complete sets of books directly for a reasonable price ($100 for the 4 books in softcover).

Update: Chapter 3 of Alberto Cairo’s The Functional Art has a great discussion of the good and bad aspects of Tufte, and the “religious war” with designers like Holmes. Cairo is somehow fair and kind to both sides. Cairo’s books are awesome. I recommend them.

Colin Ware’s Visual Thinking for Design is the “second” textbook. Munzner (by her own admission) doesn’t cover the connection to perception well. So, we need another book.The library has it online!

Fortunately, you don’t need to buy this book. It is available in the online reserves through the UW library. Yes, you can read it online!

If you want to buy a copy, it should be available at the UW bookstore. Or, you can buy it on Amazon (Visual Thinking: for Design”) – if you like Amazon.

Why is this the textbook?

This is a thin little book that will give you some of the elements of how the human visual system works, well contextualized with how that influences visual design and visualization. It is concise and generally well thought out. It doesn’t take the place of a more thorough introduction to perception, or a more thorough discussion of visualization, or even a touch into the research that connects perception to visualization. But it’s a great starting point.

I think this book is a great place to start for thinking about how perception influences visualization. So I will recommend we start with it. We’ll pretty much read the whole thing. Parts are better than others.

Ware’s other book (Information Visualization, Third Edition: Perception for Design) is also really good – and I considered it as the text for this class. However, its a lot more to read, and it still just focuses on the perceptual side of visualization.

Tamara Munzner’s Visualization Analysis and Design is the primary textbook for this class. It is required. We will read a lot of the chapters as required reading. The book just came out (it only began to ship in hardcover form in November), so its fresh and new (you aren’t going to find any used copies).

However, there is some good news: you don’t need to buy the book! The UW library owns the online version, so you can read the book online! You can find it here. If you want to own a physical copy of the book, it should be on sale at the UW Bookstore. Or you can buy it at Amazon (Visualization Analysis and Design (AK Peters Visualization Series)). (for my feelings on Amazon, read this).

Why is this the textbook?

This book will give you a good way to think about visualization. It’s not about the details, or the specific techniques. It totally avoids the discussion of how to do implementation. Tamara (I refer to her by first name, since we’ve been friends for a long time) has thought long and hard about this stuff, and has a coherent way to talk about it.

A lot of the structure of the book comes from a series of papers (that you still might want to read). However, the book uses the ideas from the paper (notably the nested model) as a way to organize a lot of other stuff you need to know.

Is the book perfect? Not by a long shot. There are some topics it totally leaves out (perception, implementation, specific designs, …). We’ll get those with other readings. She tends to over-emphasize her own work.

She also has a pretty strong and specific viewpoint – which I don’t always agree with. However, since her viewpoint is (almost) always well thought out and explained, it is worth hearing. It’s just important that you get some other viewpoints as well.

(This posting is from December 2015 – before Amazon’s even more rapid diversification and growth. I think the basic message may have evolved now that Amazon seems to be taking over everything – for better or worse.)

For the books I recommend, I have provided links so you can buy them on Amazon. Some people think this is a bad thing, because they believe that Amazon is evil. If you object to Amazon, then there are other ways to get the books. For the class texts, I have requested that they be available at the UW Bookstore.

Online bookstores (Amazon in particular) are very convenient. However, they also kill off physical bookstores. Back in the old days, we used to say “support your local book store against the chains.” Now its more “support your local chain book store against the online giants.”

Worse, as online retailers get really big, they have more leverage to be even fiercer competitors and crush the smaller (local) ones. The upside of this is that some of them (notably Amazon) invest heavily in technology (which is practical to do at massive scale) which means they have even more advantages. So, they can provide even an even more competitive customer experience, and even better use their size to crush their smaller competitors. What makes this even more unfair is that the biggest retailers can subsidize their growth via the stock market (if your local store lost as much money as Amazon, they’d be out of business). The positive side is that Amazon has invested in research (they have some totally cool robot technologies for their warehouses, for example).

In France, a vibrant bookstore culture is viewed as an important part of a free society: if there is a monopoly in bookstores, there is a monopoly of ideas. For this reason, books cannot be discounted in France. Amazon is still big there, but they don’t compete on price. Anecdotally, it seems that the local bookstore scene is better in France (at least the places I visited).

All that said, I will provide you with links so that you can buy stuff from Amazon if you like. These links are set up with “affiliate” links – so that the “UW graphics group” gets a few pennies if you buy something. All those pennies are used to buy books for our lab. (you can of course, take out the affiliate part of the link and direct those pennies elsewhere).

And if you’re wondering abut my personal viewpoint: I do like to buy local, but admit that the convenience and selection of buying online means that I buy a lot of stuff that way.