Mapping vs. setting

The single most common ggplot bug is confusing mapping with setting.

ggplot(storms, 
       aes(x = wind, y = pressure,
           color = status)) +
  geom_point()

ggplot(storms, 
       aes(x = wind, 
           y = pressure)) +
  geom_point(color = "steelblue")

The classic mistake

What does this do?

ggplot(storms, aes(x = wind, y = pressure)) +
  geom_point(aes(color = "steelblue"))

Example: status mapped four ways

# Color: good for categorical
ggplot(storms, aes(x = wind, y = pressure, color = status)) + geom_point(alpha = 0.4)

# Shape: also good, but watch the 6-value limit
ggplot(storms, aes(x = wind, y = pressure, shape = status)) + geom_point()

# Size: bad: implies ranking
ggplot(storms, aes(x = wind, y = pressure, size = status)) + geom_point()

# Alpha: same problem as size
ggplot(storms, aes(x = wind, y = pressure, alpha = status)) + geom_point()

Using size/alpha for a discrete variable is not advised.

The stroke aesthetic

For filled point shapes (21–25), stroke controls border thickness independently of size.

ggplot(storms |> filter(category >= 4), 
       aes(x = wind, y = pressure, fill = factor(category))) +
  geom_point(shape = 21, size = 3, stroke = 1.2, color = "white") +
  labs(fill = "Category")

A white stroke around colored points is one of the easiest ways to make a busy plot readable.

On-the-fly transformations

Aesthetics don’t have to map to a variable name; they can map to any expression involving variables.

ggplot(storms, 
       aes(x = wind, y = pressure, color = wind >= 64)) +
  geom_point(alpha = 0.3) +
  labs(color = "Hurricane-strength?")

The expression wind >= 64 returns TRUE/FALSE for each row, and that gets mapped to color. No need to create the column in advance.

Layering: more than one geom

A plot can have as many geoms as you want. They stack in the order you write them.

ggplot(storms, aes(x = wind, y = pressure)) +
  geom_point(alpha = 0.2) +
  geom_smooth(color = "firebrick")

Here we have two layers, the same data, and the same mappings. The points show every observation; the smooth shows the trend.

Global vs. local mappings

You can put aes() in two places:

ggplot(storms, 
       aes(x = wind, y = pressure)) +
  geom_point() +
  geom_smooth()

ggplot(storms, 
       aes(x = wind, y = pressure)) +
  geom_point(aes(color = status)) +
  geom_smooth()

Why local mappings matter

If you put color = status in the global aes(), every layer sees it. geom_smooth() will draw one smoother per status, not one overall.

# One smoother per status (probably not what you want here):
ggplot(storms, aes(x = wind, y = pressure, color = status)) +
  geom_point(alpha = 0.2) +
  geom_smooth()

# Points colored by status, one global smoother:
ggplot(storms, aes(x = wind, y = pressure)) +
  geom_point(aes(color = status), alpha = 0.2) +
  geom_smooth()

Where you put the mapping changes the plot. There’s no “right” choice (just be intentional in your choices.)

Different data per layer

Each layer can have its own data. This is how you highlight a subset.

katrina <- storms |> filter(name == "Katrina", year == 2005)

ggplot(storms |> filter(year == 2005), 
       aes(x = long, y = lat)) +
  geom_path(aes(group = name), alpha = 0.2) +
  geom_path(data = katrina, color = "firebrick", linewidth = 1.2) +
  geom_point(data = katrina, color = "firebrick") +
  labs(title = "2005 Atlantic hurricane season, with Katrina highlighted")

Three layers: all storms (faint), Katrina’s path (red), Katrina’s observations (red dots). Each calls data = locally to override the default.

The group aesthetic

Some geoms — lines, smoothers, polygons — connect multiple rows. They need to know which rows belong together.

If you map a discrete variable to color or linetype, ggplot groups for you automatically. If you don’t, you may need to set group explicitly.

# Bad: one giant line zigzagging between every storm
ggplot(storms |> filter(year == 2005), aes(x = long, y = lat)) +
  geom_path()

# Good: one path per storm
ggplot(storms |> filter(year == 2005), aes(x = long, y = lat, group = name)) +
  geom_path()

group doesn’t add a legend or change colors, it just splits the geom.

Where do bar heights come from?

Here’s a (potentially) tricky question:

ggplot(storms, aes(x = status)) +
  geom_bar()

We told ggplot about x = status. Where did the y-axis (count) come from?

Three reasons to touch the stat

1. You already pre-computed the values. We can override the default behavior of geom_bar with stat = "identity".

storm_counts <- storms |> count(status)
storm_counts

# A tibble: 9 × 2
  status                     n
  <fct>                  <int>
1 disturbance              212
2 extratropical           2318
3 hurricane               5100
4 other low               1623
5 subtropical depression   154
6 subtropical storm        323
7 tropical depression     3685
8 tropical storm          7252
9 tropical wave            111

ggplot(storm_counts, aes(x = status, y = n)) +
  geom_bar(stat = "identity")   # or just use geom_col(), it's the same thing

geom_col() is a shortcut for geom_bar(stat = "identity"). You can use it when you have your own y values.

Three reasons to touch the stat

2. You want a computed variable, not the default.

stat_count() actually computes two things: count (default) and prop (proportion). You can ask for the proportion using after_stat():

ggplot(storms, aes(x = status, y = after_stat(prop), group = 1)) +
  geom_bar()

Three reasons to touch the stat

3. You want to make the transformation explicit. Use a stat_*() function directly.

ggplot(storms, aes(x = status, y = wind)) +
  stat_summary(
    fun.min = min,
    fun.max = max,
    fun = median
  )

This shows the min, median, and max wind speed for each status without you having to manually write any dplyr code first. stat_summary() does the aggregation as part of the plot.

after_stat() quick overview

Anywhere you’d write a variable name inside aes(), you can wrap it in after_stat(...) to refer to a computed variable instead of one in the original data.

# Default: bin counts on y
ggplot(storms, aes(x = wind)) +
  geom_histogram(binwidth = 5)

# Same bins, but density on y instead
ggplot(storms, aes(x = wind, y = after_stat(density))) +
  geom_histogram(binwidth = 5)

To see what’s available for a given geom, run ?geom_bar and look for the Computed variables section.

Stacking (the default for filled bars)

hurricanes <- storms |> filter(status == "hurricane")

ggplot(hurricanes, aes(x = month, fill = factor(category))) +
  geom_bar()

Each month gets one bar; segments stack by hurricane category.

This is useful for showing total and composition at once, but hard to compare middle segments across bars (their bottoms aren’t aligned).

position = "fill"

Here we have the same code, but every bar is normalized to height 1:

ggplot(hurricanes, aes(x = month, fill = factor(category))) +
  geom_bar(position = "fill")

Now the y-axis is proportion, not count. Loses information about total volume, but makes the composition easy to compare across months.

position = "dodge"

Here are the bars side-by-side instead of stacked:

ggplot(hurricanes, aes(x = month, fill = factor(category))) +
  geom_bar(position = "dodge")

This is the easiest version for comparing individual counts directly. The trade-off: lots of bars, can get crowded fast.

Jittering — for scatterplots, not bars

A different problem: many storm observations are recorded only every 6 hours, and pressure readings are rounded to whole millibars. Lots of points overlap.

# Lots of overplotting since points are stacked on top of each other
ggplot(storms, aes(x = category, y = wind)) +
  geom_point()

# Spread them out a bit
ggplot(storms, aes(x = category, y = wind)) +
  geom_point(position = "jitter", alpha = 0.3)

# Shorthand for the same thing
ggplot(storms, aes(x = category, y = wind)) +
  geom_jitter(alpha = 0.3)

Jitter adds tiny random noise so points stop landing on top of each other. You lose precision but (often) can gain a clear picture of density.

Don’t over-jitter

geom_jitter() takes width and height arguments. Defaults are usually fine, but:

• Categorical x: small width (~0.2), height = 0 to keep y meaningful.
• Integer x and y: small jitter on both.
• Continuous data: you probably don’t need jitter at all, just use alpha or geom_hex()/geom_bin2d() instead.

ggplot(storms, aes(x = factor(category), y = wind)) +
  geom_jitter(width = 0.2, height = 0, alpha = 0.3)