Perception & Design

PSY 410: Data Science for Psychology

Dr. Sara Weston

2026-04-27

How we see data

This first block (~25 min) covers perception, color theory, and decluttering. The opening “what’s wrong” slide is meant to be interactive — pause and let students call out problems before revealing the answer. Assignment 3 is due this week and Assignment 4 (Visualization Deep Dive) is assigned today.

What’s wrong with this?

Red-green palette (colorblind-unfriendly). No informative title. Tiny text. Gridline noise. Bars hiding the data.

Today we learn why your brain rejects bad figures — and how to design ones that work.

Let the reveal build naturally — use the pause (. . .) to give students 30 seconds to identify problems on their own first. Cold-call a few students or ask pairs to share. Most will catch the red-green issue since we mentioned it last session. Fewer will notice the bar chart hiding data or the uninformative title. This sets up the whole session: design isn’t decoration, it’s communication.

Your brain processes some visual features before you even think

Some visual features are processed almost instantly — before conscious attention kicks in:

Attribute	Example
Color	A red dot among blue dots
Size	A large circle among small ones
Position	A point far from the others
Shape	A triangle among circles
Orientation	A tilted bar among vertical bars

These are your tools for drawing the viewer’s eye.

This connects directly to psych content students may have seen in intro psych or perception courses. Preattentive processing happens in ~250ms — before conscious attention. The practical implication for data viz: if you want something to stand out, use one of these attributes. If you use too many at once, nothing stands out. Spend ~3 minutes here. Students often ask about animation — yes, motion is preattentive too, but we won’t use it in static figures.

Preattentive in action

Your eye goes to the red points, the big points, and the outlier — instantly.

Ask students: “Where did your eye go first in each panel?” The answer should be obvious and immediate — that’s the whole point. The practical takeaway: use color to highlight your key finding, not to decorate. If everything is colorful, nothing pops.

Working memory limits what you can encode

This is direct cognitive psychology. Cowan (2001) revised Miller’s “7 ± 2” downward — the real capacity is closer to 4 chunks. The visualization implication: each aesthetic you use (color, shape, size) occupies a working memory slot. Eight-category legends fail because readers literally cannot hold all eight color-group mappings in memory while reading the figure. This is the scientific basis for the “max 5 colors” rule of thumb. Spend ~3 minutes here and connect it back to the preattentive slide: just because a viewer notices something (preattentive) doesn’t mean they can track it across categories (working memory).

Research suggests working memory holds roughly 4 items at a time (Cowan, 2001).

In data visualization, this means:

• Limit categorical groups in a legend to 4–5 maximum
• Each additional aesthetic (color, shape, size) uses up a “slot”
• If you have 8 conditions, consider faceting rather than overlapping

Gestalt principles: how the brain groups things

Give students a moment to look at each panel before reading the label. The proximity demo is obvious — two clusters, same color, same size. Similarity is more interesting: identical positions, but color alone makes two groups pop out. Enclosure shows up everywhere: annotation boxes, facet borders, legend boxes. All three operate automatically and unconsciously — whether or not you designed them in. This is a 5-minute slide; use the fragment reveals to pace the conversation.

The brain automatically groups visual elements — whether you intend it or not.

Proximity

Nearby items feel like a group

Similarity

Same appearance = same group

Enclosure

Inside a border = same group

Gestalt principles show up everywhere in ggplot2

This is the “so what?” slide for Gestalt. Students often treat these principles as abstract theory — this slide makes them concrete and actionable. The key insight: every ggplot2 function that creates grouping or spatial structure (facets, color scales, annotation boxes) is activating these principles automatically. Good designers make this work for them; bad designers accidentally create misleading groupings. Spend 2–3 minutes. The annotate("rect") example is a useful technique they haven’t seen yet.

Principle	How it shows up in your figures
Proximity	facet_wrap() puts related panels side by side
Similarity	Color-coding makes same-group points feel connected
Enclosure	A shaded background or border sets a group apart
Continuity	Connecting points across time implies a single trend

These groupings happen whether you design them or not — use them intentionally.

Color theory

Three types of color palettes

Type	When to use	Example
Sequential	One continuous variable (low → high)	Blues, viridis
Diverging	Values relative to a midpoint	Red–white–blue
Qualitative	Categorical groups (no order)	Set1, tab10

Using the wrong type is one of the most common visualization mistakes.

This is a high-value slide — spend ~3 minutes here. The most common mistake: using a qualitative palette for ordered data (like a rainbow for low-to-high), or using a sequential palette for unrelated categories. Ask students: “If you had data on anxiety levels from low to high, which palette type?” (Sequential.) “If you had data on four different therapy types?” (Qualitative.) Test their intuition before moving to examples.

First question: fill or color?

This slide introduces the two-family structure. Every scale_ function starts with either scale_fill_ or scale_color_ — which one depends on the aesthetic the student mapped in aes(). This is a pattern they’ve seen already with scale_fill_manual and scale_color_manual in session 8. The new idea is that the same pattern applies to every other palette function. Keep this short — 1–2 minutes — and emphasize it’s the same pattern they already know.

Which aesthetic did you map in aes()? That tells you which scale family to use.

# Geoms with `fill=`: bars, boxplots, tiles, density
ggplot(data, aes(x, y, fill = group)) + geom_boxplot() +
  scale_fill_manual(values = c(...))     # ← scale_fill_*

# Geoms with `color=`: points, lines
ggplot(data, aes(x, y, color = group)) + geom_point() +
  scale_color_manual(values = c(...))    # ← scale_color_*

Same pattern, just swap fill for color throughout.

Second question: which palette?

Now that they know which family (fill vs color), they need to pick a palette. This table organizes the choice by data type, which is how students should be thinking about it. The _c vs _d distinction is the single most common point of confusion — call it out explicitly. Reassure students that viridis is already built into ggplot2 — no new package to install. Spend 3 minutes on this slide; students will come back to it as a reference.

Match the palette to your data:

Your data	Function
Continuous numeric (e.g., reaction time)	scale_fill_viridis_c()
Ordered categories (e.g., dosage levels)	scale_fill_viridis_d()
Qualitative groups (e.g., therapy type)	scale_fill_brewer(palette = "Set2")
Diverging from a midpoint (e.g., change scores)	scale_fill_distiller(palette = "RdBu")
Hand-picked colors	scale_fill_manual(values = c(...))

_c for numeric, _d for character/factor. Same options work for scale_color_*.

Sequential palettes

Diverging palettes

The key concept here: a diverging palette has a meaningful midpoint, usually white or a neutral color. Values above and below the midpoint get contrasting hues. In psychology, pre–post difference scores are a clean example — zero means “no change,” positive means “got worse,” negative means “got better.” Students often try to use sequential palettes for diverging data — the result is that the negative values and positive values look like they’re on the same continuum with no center. Ask: “If I have anxiety change scores from -5 (better) to +5 (worse), which palette type?” (Diverging.) Correlation matrices are another classic use case but we won’t cover correlations until Session 17.

Use when values diverge from a meaningful midpoint — often 0 or a baseline.

Qualitative palettes

Colorblind-friendly choices

Emphasize that 8% of men is roughly 1 in 12 — in a class of 50, there are likely 2-3 students with some color vision deficiency. This is not an edge case. The practical advice is simple: use viridis or a tested palette, and never rely on color alone (also use shape or labels). Students often ask “how do I check?” — suggest the colorblindness simulator at davidmathlogic.com/colorblind or the colorblindr R package.

About 8% of men have some form of color vision deficiency. Red-green is the most common.

# viridis is colorblind-safe AND sequential
scale_fill_viridis_d()   # discrete
scale_fill_viridis_c()   # continuous

# ColorBrewer palettes designed for colorblindness
scale_fill_brewer(palette = "Set2")

# Or set colors manually with safe choices
scale_fill_manual(values = c("#0072B2", "#E69F00", "#009E73"))
# (blue, orange, green — distinguishable for most color vision types)

A bad color choice vs a good one

Let the side-by-side comparison speak for itself. The blue-orange version on the right is distinguishable to virtually all viewers. You can mention that some journals now require colorblind-accessible figures. The hex codes shown earlier (#0072B2, #E69F00, #009E73) are from the Okabe-Ito palette — a safe default students can copy into any project.

Why cluttered figures fail: cognitive load theory

Cognitive load theory (Sweller, 1988) was developed to explain why instructional design matters — and it translates directly to data visualization. The three-type model gives students a vocabulary for critiquing figures: “the gridlines add extraneous load,” “the uninformative title doesn’t build germane load.” Spend ~3 minutes here, then connect forward: the declutter checklist on the next slides is how we operationalize this theory. Students who have taken cognitive psych or educational psych will recognize this framework.

Cognitive load theory (Sweller, 1988) says mental effort has three components:

Intrinsic load

The complexity of the data itself — you can’t reduce it

Extraneous load

Clutter, noise, redundant elements — this is what we control

Germane load

The insight the reader builds — what we’re trying to maximize

Every gray background, redundant legend, and unlabeled variable is extraneous load — it taxes working memory without adding information.

Design goal: minimize extraneous, maximize germane.

Decluttering

The default is cluttered

Transition: “Now that we know what to show, let’s talk about what to remove.” This section draws heavily on Knaflic’s “declutter” philosophy. The before/after comparison here is dramatic — the gray background, heavy gridlines, and redundant legend all add zero information. Students sometimes resist removing gridlines because they think figures look “empty” without them. Remind them: if the reader needs a gridline to read the value, add a direct label instead.

ggplot2’s default theme adds a lot of visual noise. Compare:

The declutter checklist

This is a reference slide students should internalize. Walk through the “Remove” column and ask students to justify each removal — e.g., “Why remove the legend when we have two conditions?” (Because the x-axis already labels them.) The “Keep” column matters too: titles should state a finding, not label the chart type. “Boxplot of RT” is a label; “Treatment reduces reaction time” is a finding.

Ask: does this element help the reader understand the data?

Remove

Element	Why
Gray background	Noise, no info
Gridlines (most)	Distraction
Redundant legend	X-axis says it
Generic axis labels	Add units instead

Keep

Element	Why
Title + subtitle	Orients the reader
Caption	Source, N, error bar type
Meaningful color	Highlights comparisons

Meet the element_* family

Before showing a full theme() call, introduce the vocabulary. Every non-data piece of a ggplot — the title, the axis ticks, the panel background, the gridlines — is one of four kinds of thing: text, a line, a rectangle, or blank (invisible). Once students internalize this, theme() stops feeling random. Spend 2–3 minutes on this slide. Ask: “The axis label — is that text, a line, or a rectangle?” (Text.) “The panel background?” (Rectangle.) “The gridlines?” (Lines.) That builds the mental model.

Every non-data piece of a ggplot is one of four kinds of thing:

Function	Key arguments	Used for
element_text()	size, face, color, hjust	Titles, axis text, legend text
element_line()	color, linewidth	Axis lines, gridlines, ticks
element_rect()	fill, color	Panel background, legend box
element_blank()	—	Removes the element entirely

theme() puts elements to use

Now that students know the four element types, theme() makes sense: you name a piece of the plot on the left side of =, and assign an element function on the right to style it. Walk through each line of the example and ask students to identify which element type is being used and why. The ?theme tip is important — there are ~90 arguments and no one memorizes them all; students should know where to look.

Inside theme(), name the piece of the plot, then assign an element_* function to style it:

theme(
  plot.title      = element_text(face = "bold", size = 16),  # text → bold, larger
  panel.grid      = element_line(color = "gray90"),           # lines → subtle gray
  plot.background = element_rect(fill = "white"),             # rect → white background
  axis.ticks      = element_blank(),                          # blank → remove ticks
  legend.position = "none"                                    # special: just "none"/"top"/etc.
)

Not sure what an argument is called? Run ?theme — there are ~90 options.

Pair coding break

Your turn: 10 minutes

Give 10 minutes. The cluttered graph on the next slide has at least 7 problems: red-green colors, size mapped to accuracy (binary variable — misleading), no informative title, variable names as axis labels, default gray theme, redundant color and fill, and points plotted behind the boxplot. Circulate and ask pairs to name each problem before they start fixing it. Common student approach: they’ll fix the colors first because it’s most obvious. Push them to also address the title and labels.

I’ll put a cluttered graph on screen. With a partner, rewrite it to follow the design principles we just covered.

Remove at least 5 unnecessary elements. Make it tell a clear story.

Tip

Think about: colors, legend, labels, theme, size mapping, and whether every aesthetic is adding information.

Your turn: 10 minutes

First, run this to create the dataset:

set.seed(123)
reaction_data <- tibble(
  participant = rep(1:40, each = 2),
  condition   = rep(c("Control", "Treatment"), 40),
  rt          = c(rnorm(40, mean = 520, sd = 60), rnorm(40, mean = 480, sd = 55)),
  accuracy    = c(rbinom(40, 1, 0.82), rbinom(40, 1, 0.88)),
  age_group   = rep(c("Young", "Young", "Older", "Older"), 20)
) |>
  mutate(rt = round(rt, 1))

Now fix this:

# The cluttered version — fix this!
reaction_data |>
  ggplot(aes(x = condition, y = rt, fill = condition, color = condition, size = accuracy)) +
  geom_point() +
  geom_boxplot(alpha = 0.3) +
  scale_fill_manual(values = c("Control" = "red", "Treatment" = "green")) +
  scale_color_manual(values = c("Control" = "red", "Treatment" = "green")) +
  labs(x = "condition", y = "rt", title = "data") +
  theme_gray()

Solution: Redesigned reaction time figure

reaction_data |>
  ggplot(aes(x = condition, y = rt,
             fill = condition,
             color = condition)) +
  geom_jitter(width = .1) +
  geom_boxplot(alpha = 0.3) +
  scale_fill_viridis_d() +
  scale_color_viridis_d() +
  scale_y_continuous(
    labels = scales::label_number(suffix = " ms")) +
  labs(
    x = NULL,
    y = NULL,
    title = "Reaction time by condition and accuracy",
    caption = "Reaction time in miliseconds; 0 = inaccurate, 1 = accurate"
  ) +
  facet_wrap(~accuracy,
             labeller = as_labeller(c("0" = "incorrect", "1" = "correct"))) +
  theme_bw() +
  theme(legend.position = "none",
        plot.title.position = "plot")

Solution: output

Critiquing bad graphs

This section (~10 min) is the second lecture block. It transitions from “how to build good figures” to “how to spot bad ones.” These three examples each illustrate a different category of problem: misleading axes, poor aesthetics, and wrong chart type. Run through them interactively — show the figure, let students diagnose it, then reveal the answer. This builds the critical evaluation skill they’ll need for Assignment 4.

What’s wrong here? (1 of 3)

The problem: The y-axis starts at 478, not 0. The difference looks massive — but it’s only ~40 ms. A truncated axis exaggerates the effect.

Students often ask: “But isn’t it sometimes okay to not start at zero?” Good question. For bar charts, no — the bar height represents the value, so truncating is always misleading. For line charts or dot plots, it can be acceptable because the position (not the area) encodes the value. This nuance matters and comes up in the storytelling session (Session 16) too.

What’s wrong here? (2 of 3)

The problems: Red-green palette (colorblind-unfriendly). Title says “Boxplot” (a label, not a finding). Variable names as labels. Distracting background color and gridlines.

What’s wrong here? (3 of 3)

The problems: Continuous data was binned into arbitrary categories, then displayed as a pie chart. We lost the actual reaction times, the condition comparison, and the ability to see distributions. A histogram or density plot would show far more.

This is the strongest example because it shows a cascade of bad decisions: first they binned continuous data (losing information), then they used a pie chart (making comparison harder), and they dropped the condition variable entirely. Each step destroyed information. The lesson: your choice of chart type determines what story you can tell. A pie chart here makes it impossible to compare conditions or see the distribution.

Get a head start

Assignment 4 preview

Assignment 4 is being assigned today. Briefly outline the three parts so students know what to aim for. Emphasize that the “bad” version should be deliberately bad with specific design violations they can name — not just ugly. They need to articulate what’s wrong with it and why the good version is better. The colorblind-accessible version is a separate deliverable, not just “the good version with viridis.”

Assignment 4 will ask you to:

1. Create a “bad” version of a figure — deliberately violate design principles
2. Create a “good” version following what we covered today
3. Create a colorblind-accessible version

Assignment 4 preview

Start experimenting now:

• Take the reaction_data dataset
• Make the worst possible version of a figure
• Then make it great
• What did you change?

Wrapping up

Design principles checklist

• Is the geom appropriate for the data type?
• Are colors colorblind-friendly?
• Is the legend necessary? (Remove if redundant)
• Are axis labels informative (not just variable names)?
• Is there a title that states the main point?
• Is there visual clutter to remove?
• Do error bars have a caption explaining what they show?

Before next class

📖 Read:

• R4DS Ch 10: Exploratory data analysis (sections 10.1–10.4)

✅ Practice:

• Try the “bad vs good” exercise on your own
• Find a graph online and identify ways to improve it

Key takeaways

1. Preattentive processing — your brain detects color, size, and position before conscious thought
2. Working memory — limit categories to 4–5; every aesthetic uses a slot
3. Gestalt principles — proximity, similarity, and enclosure create grouping automatically
4. Cognitive load — minimize extraneous clutter so the insight can land
5. Palette choice — match sequential, diverging, or qualitative to your data type
6. Design for colorblindness — always; 1 in 12 men has color vision deficiency

These are not design opinions — they are perceptual psychology.

The one thing to remember

You’re not designing for yourself. You’re designing for a reader who will look at your figure for five seconds.

Next time: Exploratory Data Analysis

End on this line — it reframes everything from today. Students naturally design for themselves (they already know what the data shows). The challenge is designing for someone who doesn’t. Five seconds is roughly how long a reader spends on a figure before deciding whether to engage. Next session shifts from how to present data to how to explore it (EDA). Remind students that Assignment 3 is due this week and Assignment 4 is now available.