Scatter plots (geom_point) in R Programming - Deep Dive

Overview - Scatter plots (geom_point)

What is it?

A scatter plot is a type of graph that shows points representing values for two different variables. In R, the geom_point function from the ggplot2 package is used to create these plots by placing dots on a grid where the x and y coordinates correspond to the variables' values. This helps us see patterns, relationships, or clusters between the two variables. Scatter plots are simple but powerful tools for visualizing data.

Why it matters

Scatter plots help us understand how two things relate to each other, like height and weight or hours studied and test scores. Without scatter plots, it would be hard to spot trends or unusual points in data quickly. They make complex data easier to grasp and support better decisions based on what the data shows. This visual insight is crucial in fields like science, business, and social studies.

Where it fits

Before learning scatter plots, you should know basic R programming and how to install and load packages like ggplot2. After mastering scatter plots, you can explore more complex visualizations like line plots, bar charts, and adding layers such as smoothing lines or customizing points with colors and sizes.

Mental Model

Core Idea

A scatter plot places dots on a grid where each dot's position shows the values of two variables, revealing their relationship visually.

Think of it like...

Imagine a city map where each dot is a house located by its street (x-axis) and avenue (y-axis). The pattern of houses shows how neighborhoods form and relate to each other.

  Y-axis
    ↑
    │       •     •
    │    •     •
    │  •
    │
    └────────────────→ X-axis
      (variable 1)

Build-Up - 7 Steps

1

Foundation

Understanding basic scatter plot concept

Concept: Learn what a scatter plot is and what it shows.

A scatter plot is a graph with points plotted to show the relationship between two variables. Each point's horizontal position shows one variable's value, and the vertical position shows the other variable's value. This helps us see if the variables move together or not.

Result

You can explain what a scatter plot represents and identify the axes as variables.

Understanding the basic idea of plotting two variables as points is the foundation for all scatter plot work.

2

Foundation

Installing and loading ggplot2 package

Concept: Learn how to prepare R to create scatter plots using ggplot2.

To make scatter plots in R, you need the ggplot2 package. You install it once with install.packages("ggplot2") and load it in each session with library(ggplot2). This package provides the geom_point function to draw scatter plots.

Result

You can load ggplot2 and are ready to create scatter plots.

Knowing how to set up your tools is essential before creating any plot.

3

Intermediate

Creating a simple scatter plot with geom_point

🤔Before reading on: do you think geom_point needs data in a special format or any arguments? Commit to your answer.

Concept: Learn how to use ggplot and geom_point to plot two variables from a data frame.

Use ggplot(data, aes(x=var1, y=var2)) + geom_point() to create a scatter plot. The aes() function tells ggplot which variables to use for x and y axes. geom_point() adds the dots. For example, with mtcars dataset, ggplot(mtcars, aes(x=wt, y=mpg)) + geom_point() plots car weight vs. miles per gallon.

Result

A scatter plot appears showing points for each car's weight and mpg.

Understanding how aes() maps variables to axes and how geom_point adds points is key to making scatter plots.

4

Intermediate

Customizing points with color and size

🤔Before reading on: do you think color and size can be set to fixed values or mapped to variables? Commit to your answer.

Concept: Learn how to change point appearance by setting or mapping color and size.

You can set color and size to fixed values like geom_point(color="blue", size=3) to make all points blue and bigger. Or map them to variables inside aes(), like aes(color=gear, size=hp), to show groups or magnitude visually. This adds more information to the plot.

Result

Points appear colored or sized differently based on data, making patterns clearer.

Knowing how to map aesthetics to variables enriches the plot's storytelling power.

5

Intermediate

Adding labels and titles for clarity

Concept: Learn to add descriptive titles and axis labels to make plots understandable.

Use labs(title="Car Weight vs MPG", x="Weight (1000 lbs)", y="Miles per Gallon") to add a title and axis labels. This helps anyone reading the plot know what the data represents without guessing.

Result

The plot shows clear titles and axis names, improving communication.

Clear labels prevent confusion and make your visualizations accessible to others.

6

Advanced

Handling overplotting with transparency

🤔Before reading on: do you think many overlapping points can hide data patterns? Commit to your answer.

Concept: Learn to use transparency to see overlapping points better.

When many points overlap, it’s hard to see density. Adding alpha=0.5 inside geom_point() makes points semi-transparent, so overlapping points appear darker. For example, geom_point(alpha=0.5) helps reveal clusters in dense data.

Result

Dense areas become visible as darker spots, showing data concentration.

Using transparency solves a common problem in scatter plots with many points.

7

Expert

Using jitter to avoid point overlap

🤔Before reading on: do you think points with identical values appear as one dot? Commit to your answer.

Concept: Learn to add small random noise to points to separate overlapping points.

When points share the same x and y values, they overlap exactly. geom_jitter() adds small random shifts to points to spread them out. For example, ggplot(data, aes(x, y)) + geom_jitter(width=0.1, height=0.1) moves points slightly so all are visible.

Result

Points that were hidden behind others become visible, improving data clarity.

Knowing how to use jitter prevents misleading plots caused by overlapping points.

Under the Hood

ggplot2 builds plots by layering components. When you call ggplot(), it creates a plot object with data and aesthetic mappings. geom_point() adds a layer that draws each data point as a graphical object (a dot) at coordinates determined by the mapped variables. Internally, ggplot2 uses grid graphics to render these points on the plotting device. Parameters like color, size, and alpha control the graphical properties of each point. The layering system allows combining multiple geoms and customizations seamlessly.

Why designed this way?

ggplot2 was designed following the Grammar of Graphics, which breaks plots into semantic components like data, aesthetics, and geometric objects. This modular design makes plots flexible and composable. Using layers lets users add or remove elements easily. The separation of data and appearance mappings helps avoid confusion and makes code readable. Alternatives like base R plotting are less structured and harder to extend, so ggplot2’s design improves clarity and power.

┌─────────────┐
│  ggplot()   │  ← creates plot object with data and mappings
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ geom_point()│  ← adds points layer using data and aesthetics
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ grid system │  ← renders points graphically on device
└─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does setting color inside aes() and outside aes() do the same thing? Commit to yes or no.

Common Belief: Setting color inside or outside aes() changes point color the same way.

Reality: Setting color inside aes() maps color to a variable, creating a legend and varying colors. Setting color outside aes() sets a fixed color for all points with no legend.

Why it matters: Confusing these causes plots to either lose meaningful color grouping or show incorrect legends, misleading interpretation.

Quick: Do you think geom_point() can plot more than two variables at once? Commit to yes or no.

Common Belief: geom_point() can directly plot three or more variables on the same scatter plot.

Reality: geom_point() plots only two variables on x and y axes; other variables can be shown by mapping to color, size, or shape, but not as extra axes.

Why it matters: Expecting more axes leads to confusion; understanding aesthetics mapping avoids misuse and helps effective visualization.

Quick: Does adding alpha always improve scatter plot readability? Commit to yes or no.

Common Belief: Adding transparency (alpha) always makes scatter plots easier to read.

Reality: Alpha helps with overplotting but can make points too faint if set too low or if data is sparse, reducing clarity.

Why it matters: Blindly using alpha can hide data instead of revealing it, causing misinterpretation.

Quick: Is geom_jitter() the same as geom_point() with alpha? Commit to yes or no.

Common Belief: geom_jitter() just adds transparency like alpha in geom_point().

Reality: geom_jitter() adds random noise to point positions to separate overlapping points, while alpha changes transparency; they solve different problems.

Why it matters: Mixing these up leads to ineffective plots where overlapping points remain hidden.

Expert Zone

1

Mapping color to a continuous variable automatically creates a gradient scale, but mapping to a categorical variable creates discrete colors; knowing this helps tailor legends.

2

Using shape aesthetic with more than six categories can confuse viewers because ggplot2 supports only a limited set of distinct shapes.

3

Combining jitter with alpha transparency can reveal dense clusters without overwhelming the plot, but requires careful tuning to avoid noise.

When NOT to use

Scatter plots are not suitable for categorical variables without numeric meaning or for very large datasets where overplotting overwhelms the plot. Alternatives include boxplots for categories or hexbin plots and density plots for large data.

Production Patterns

Professionals often combine geom_point with geom_smooth to add trend lines, use faceting to split data by groups, and customize themes for consistent styling across reports. Interactive scatter plots with tools like plotly are also common for deeper data exploration.

Connections

Correlation coefficient

Scatter plots visually show relationships that correlation coefficients measure numerically.

Understanding scatter plots helps interpret correlation values by seeing the actual data distribution behind the number.

Heatmaps

Both visualize data density but heatmaps use color intensity on a grid, while scatter plots show individual points.

Knowing scatter plots clarifies when to switch to heatmaps for large datasets to better see density patterns.

Astronomy star maps

Scatter plots and star maps both plot points in space to reveal patterns and clusters.

Recognizing this connection shows how data visualization principles apply across science and art.

Common Pitfalls

#1 Plotting points without specifying data or aesthetics.

Wrong approach:

ggplot() + geom_point()

Correct approach:

ggplot(data, aes(x=var1, y=var2)) + geom_point()

Root cause:

Forgetting to provide data and variable mappings leaves ggplot with no information to plot.

#2 Setting color inside aes() when a fixed color is intended.

Wrong approach:

geom_point(aes(color="blue"))

Correct approach:

geom_point(color="blue")

Root cause:

Confusing mapping (aes) with setting fixed values causes unintended legends and color behavior.

#3 Ignoring overplotting in large datasets.

Wrong approach:

ggplot(large_data, aes(x, y)) + geom_point()

Correct approach:

ggplot(large_data, aes(x, y)) + geom_point(alpha=0.3) or geom_jitter()

Root cause:

Not addressing overlapping points hides data patterns and misleads analysis.

Key Takeaways

Scatter plots use points to show how two variables relate by their positions on x and y axes.

In R, geom_point from ggplot2 creates scatter plots by mapping data variables to aesthetics.

Customizing point color, size, and transparency adds layers of information to the plot.

Handling overlapping points with alpha transparency or jitter improves plot clarity.

Understanding the grammar of graphics behind ggplot2 helps create flexible and powerful visualizations.