Putting It All Together

PSY 410: Data Science for Psychology

Dr. Sara Weston

2026-06-03

Looking back

This is the last class session. The tone should feel celebratory and reflective, not rushed. Students have their final projects due today and presentations during finals week. Start with a warm opening – acknowledge that it’s the end, and that you’re proud of how far they’ve come. The first ~10 minutes are about reflection before moving into the live demo.

The data science workflow

R4DS data science workflow diagram showing the cycle: Import, Tidy, Transform, Visualize, Model, Communicate

Ten weeks ago, you couldn’t do any of this. Now you can do all of it.

Let this diagram sit for a moment. Ask students to name which sessions covered which parts of the cycle. Import (Session 6), Tidy (Session 5), Transform (Sessions 3-4), Visualize (Sessions 2, 8-9), Model (Session 17), Communicate (Sessions 7, 16). The point is that they’ve covered the entire workflow. This is the same R4DS diagram from the textbook – it should feel familiar.

Live demonstration

A real analysis: Start to finish

Let’s analyze a complete psychology dataset together.

Research question: Does social media use predict anxiety in college students?

I’ll demonstrate the full workflow:

1. Import messy data
2. Clean and tidy
3. Explore with visualizations
4. Create publication-ready figures
5. Build a Quarto report

This live demo should take ~15 minutes total (Steps 1-9). You can either advance through the slides or live-code in RStudio alongside – live-coding is more engaging if time allows. The research question deliberately mirrors what many students are doing for their final projects (social media and mental health), so it should feel relevant. Emphasize that this is the exact workflow they should use for their final project.

The dataset

# Simulated college student survey data
set.seed(2026)
social_media <- tibble(
  id = 1:200,
  age = sample(18:24, 200, replace = TRUE),
  gender = sample(c("Male", "Female", "Non-binary", "Prefer not to say"),
                  200, replace = TRUE),
  hours_social_media = rnorm(200, 4, 2),
  gad7_total = rnorm(200, 8, 5),  # Generalized Anxiety Disorder scale
  phq9_total = rnorm(200, 10, 6),  # Depression scale
  academic_year = sample(c("Freshman", "Sophomore", "Junior", "Senior"),
                        200, replace = TRUE)
) |>
  mutate(
    # Make anxiety correlate with social media use
    gad7_total = gad7_total + hours_social_media * 0.8,
    # Add some missing data
    hours_social_media = if_else(runif(200) < 0.05, NA_real_, hours_social_media),
    gad7_total = if_else(runif(200) < 0.08, NA_real_, gad7_total)
  )

Step 1: Explore the data

glimpse(social_media)

Rows: 200
Columns: 7
$ id                 <int> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, …
$ age                <int> 22, 18, 18, 23, 22, 24, 20, 21, 21, 22, 24, 21, 19,…
$ gender             <chr> "Non-binary", "Prefer not to say", "Female", "Prefe…
$ hours_social_media <dbl> 3.3448174, 3.2895680, 5.5618681, 5.2173403, 6.15235…
$ gad7_total         <dbl> NA, 11.577943, 12.102962, 17.555169, 18.276343, 15.…
$ phq9_total         <dbl> 8.50042866, 8.19341562, 1.00400734, 10.20523209, 4.…
$ academic_year      <chr> "Junior", "Freshman", "Sophomore", "Freshman", "Jun…

# Check for missing data
social_media |>
  summarize(across(everything(), ~sum(is.na(.x))))

# A tibble: 1 × 7
     id   age gender hours_social_media gad7_total phq9_total academic_year
  <int> <int>  <int>              <int>      <int>      <int>         <int>
1     0     0      0                  6         13          0             0

Emphasize that the first thing to do with any dataset is glimpse() and check for missing data. These are the two moves they should make before doing anything else. Ask: “What do you notice about the missing data? Which variables have it? How much?” This connects directly back to Session 15 on missing data.

Step 2: Clean the data

social_media_clean <- social_media |>
  # Remove rows with missing outcome
  drop_na(gad7_total) |>
  # Create anxiety categories
  mutate(
    anxiety_category = case_when(
      gad7_total < 5 ~ "Minimal",
      gad7_total < 10 ~ "Mild",
      gad7_total < 15 ~ "Moderate",
      gad7_total >= 15 ~ "Severe"
    ),
    anxiety_category = factor(anxiety_category,
                              levels = c("Minimal", "Mild", "Moderate", "Severe")),
    # Reorder academic year
    academic_year = factor(academic_year,
                          levels = c("Freshman", "Sophomore", "Junior", "Senior"))
  )

Walk through each cleaning decision and explain the reasoning. “Why drop_na on the outcome variable?” Because you can’t analyze what you can’t measure. “Why create categories?” Because clinical cutoffs make the continuous scores more interpretable. “Why reorder academic year?” Because R defaults to alphabetical, which puts Freshman last. Each of these decisions connects to a specific session: drop_na (Session 15), case_when (Session 4), factor levels (Session 12).

Step 3: Descriptive statistics

social_media_clean |>
  summarize(
    n = n(),
    mean_age = mean(age),
    mean_hours = mean(hours_social_media, na.rm = TRUE),
    sd_hours = sd(hours_social_media, na.rm = TRUE),
    mean_anxiety = mean(gad7_total),
    sd_anxiety = sd(gad7_total)
  )

# A tibble: 1 × 6
      n mean_age mean_hours sd_hours mean_anxiety sd_anxiety
  <int>    <dbl>      <dbl>    <dbl>        <dbl>      <dbl>
1   187     21.0       3.97     1.93         11.9       5.42

Step 4: Initial visualization

ggplot(social_media_clean, aes(x = hours_social_media, y = gad7_total)) +
  geom_point(alpha = 0.5) +
  geom_smooth(method = "lm", color = "steelblue") +
  labs(
    title = "Social media use predicts higher anxiety",
    subtitle = "Self-reported daily hours and GAD-7 scores",
    x = "Daily social media use (hours)",
    y = "Anxiety score (GAD-7)"
  ) +
  theme_minimal()

Step 4: Initial visualization

Step 5: Compute correlation

# Clean data for correlation (remove NAs)
correlation_data <- social_media_clean |>
  drop_na(hours_social_media, gad7_total)

cor_value <- cor(correlation_data$hours_social_media,
                 correlation_data$gad7_total)

cor_value

[1] 0.3388387

Finding: Moderate positive correlation (r = 0.34)

This is a callback to Monday’s session. Ask students to interpret the correlation in plain language before you advance to the finding. “What does a positive correlation mean here?” Students who were in Session 17 should be able to answer this. Note that we drop_na before computing the correlation – reinforce the habit of handling missing data explicitly.

Step 6: Explore by gender

ggplot(social_media_clean, aes(x = hours_social_media, y = gad7_total, color = gender)) +
  geom_point(alpha = 0.5) +
  geom_smooth(method = "lm", se = FALSE) +
  labs(
    title = "Social media-anxiety relationship holds across genders",
    x = "Daily social media use (hours)",
    y = "Anxiety score (GAD-7)",
    color = "Gender"
  ) +
  theme_minimal() +
  theme(legend.position = "top")

Step 6: Explore by gender

Step 7: Anxiety categories

social_media_clean |>
  count(anxiety_category) |>
  mutate(anxiety_category = fct_rev(anxiety_category)) |>
  ggplot(aes(x = n, y = anxiety_category, fill = anxiety_category)) +
  geom_col() +
  scale_fill_manual(values = c(
    "Minimal" = "#2ecc71",
    "Mild" = "#f39c12",
    "Moderate" = "#e67e22",
    "Severe" = "#e74c3c"
  )) +
  labs(
    title = "Most students report mild to moderate anxiety",
    subtitle = "Distribution of GAD-7 severity categories (N = 184)",
    x = "Number of students",
    y = NULL
  ) +
  theme_minimal() +
  theme(legend.position = "none")

Step 7: Anxiety categories

Step 8: Create summary table

summary_table <- social_media_clean |>
  group_by(anxiety_category) |>
  summarize(
    N = n(),
    Mean_Hours = mean(hours_social_media, na.rm = TRUE),
    SD_Hours = sd(hours_social_media, na.rm = TRUE),
    Mean_Age = mean(age),
    .groups = "drop"
  )

knitr::kable(summary_table, digits = 1,
             col.names = c("Anxiety Category", "N", "M Hours", "SD Hours", "M Age"))

Anxiety Category	N	M Hours	SD Hours	M Age
Minimal	19	3.0	1.7	21.2
Mild	51	3.2	2.0	20.9
Moderate	66	4.1	1.8	20.7
Severe	51	5.0	1.5	21.2

Step 9: Write it up in Quarto

## Results

We analyzed data from 187 college students
(M age = 21 years).
Students reported using social media an average of
4
hours per day (SD = 1.9).

Social media use was positively correlated with anxiety scores
(r = 0.34, p < .001), such that students who
used social media more reported higher anxiety levels.

```{r}
#| echo: false
#| fig-cap: "Relationship between social media use and anxiety"
# [Insert scatterplot code]
```

This is the communication step – the one students often skip. Emphasize that inline R code (the backtick-r expressions) means the numbers in the writeup update automatically if the data changes. No more copy-pasting numbers from output into a Word doc. This is what makes it reproducible. If time allows, show this rendering in a Quarto document to drive the point home.

What this demonstrates

✅ Complete workflow — import to interpretation ✅ Data cleaning — handling missing data, creating factors ✅ Multiple visualizations — exploring from different angles ✅ Summary statistics — both numerical and tabular ✅ Inline reporting — no hard-coded numbers ✅ Clear narrative — telling the story

Pause here and take a breath. This checklist summarizes the entire course in six bullet points. Let students appreciate that they can now do every single one of these things. Then transition: “But what happens when things go wrong? Because they will, even for experienced programmers.”

When things break

The 6 errors you’ll see most often

Error	What it means	Fix
object 'x' not found	Typo, wrong capitalization, or object not created yet	Check spelling; run the code that creates it
could not find function	Typo in function name or package not loaded	Check spelling; run library()
unexpected symbol	Missing |>, +, comma, or parenthesis	Check the line before the error
non-numeric argument	Math on text — variable is character, not numeric	Check type with class() or glimpse()
did you mean '=='?	Used = (assignment) instead of == (comparison) in filter()	Change = to ==
ggplot + error	Missing + between ggplot layers	Every line except the last needs +

Spend ~3 minutes on this table. Ask students: “Which of these have you gotten this quarter?” Hands will go up for almost all of them. The most common by far is “object not found” (usually a capitalization issue or forgetting to run an earlier chunk). The “unexpected symbol” error is the trickiest because the actual problem is on the line before the error – emphasize checking the previous line.

A 5-step debugging strategy

1. Read the error message — actually read it. It tells you where and what.

2. Check the basics — package loaded? Object created? Spelling correct?

3. Run line by line — pipe chains: run from the top, adding one line at a time. Which line breaks?

4. Simplify — make a tiny test dataset (tibble(x = 1:3)) and try the same operation.

5. Google it — include “R”, the package name, and the exact error message.

Step 3 (“run line by line”) is the most underused debugging technique among beginners. Demo it quickly: take a piped chain, highlight just the first line and run it, then add the next line, and so on. The line where it breaks is where the bug is. This is the single most useful debugging habit they can develop. Steps 1-3 solve ~90% of bugs.

When you ask for help: make a reprex

Reprex = reproducible example — the smallest code that recreates your error.

Bad: “My code doesn’t work. Help!”

Good:

“I’m trying to filter my data but getting ‘object not found’:

library(tidyverse)
data <- tibble(x = 1:3, y = c("a", "b", "c"))
filter(data, x > 1)
# Error: object 'data' not found

I expected rows where x > 1.”

Tip: Use dput() to share a small slice of your real data so others can recreate it exactly.

The reprex concept is a life skill for programming. Emphasize the contrast between the “bad” and “good” examples. The good example includes: the library call, a minimal dataset, the code that fails, and the expected vs. actual result. Even if students never post on Stack Overflow, learning to create a reprex forces them to isolate the problem – which often helps them solve it themselves.

Where to get help after this course

• Stack Overflow — searchable Q&A (look for green checkmark ✅)
• Posit Community — friendly R forum
• R4DS Slack — real-time chat
• R-Ladies — supportive community with local chapters

Before posting: search first, be specific, show what you tried, and include a reprex.

Pair coding break

Your turn: Debug this code

This is the final pair coding exercise of the course – 10 minutes. There are 4 bugs: (1) Study_data vs study_data capitalization mismatch, (2) single = instead of == in filter, (3) Score vs score capitalization mismatch, (4) missing comma between summarize arguments. Circulate and see how quickly pairs find all four. Bug 1 and 3 (capitalization) are the trickiest because the error message just says “object not found.” Bug 2 gives a helpful error (“Did you mean ==?”). Bug 4 gives “unexpected symbol.” This exercise reinforces the debugging strategy from the previous slide.

This code has several errors. Find and fix them all:

library(tidyverse)

# Load data
Study_data <- tibble(
  id = 1:5,
  Score = c(10, 15, 12, 18, 14),
  Group = c("A", "B", "A", "B", "A")
)

# Analyze
study_data |>
  filter(Group = "A") |>
  summarize(
    mean_score = mean(score)
    sd_score = sd(score)
  )

Time: 10 minutes

Tip

There are at least 4 bugs. Read each line carefully and check: names, operators, punctuation.

Before we move on

Upload your code to Canvas for participation credit. Paste what you have into today’s in-class submission — it doesn’t need to work perfectly.

Where to go from here

You have the foundation

Transition to the forward-looking section (~10 minutes for the “Where to go from here” block). The goal is to show students that this course was the on-ramp, not the destination. Each of the next slides shows one possible direction. Don’t spend too long on any one – just plant seeds. Students who are interested will follow up on their own.

This course covered data wrangling and visualization — the foundation of data science.

What’s next?

• Statistics in R — inference, hypothesis testing
• Advanced R programming — functions, iteration
• Version control — Git and GitHub
• Interactive tools — Shiny dashboards
• Machine learning — tidymodels framework

Statistics in R

You can now learn inferential statistics:

# t-test
t.test(gad7_total ~ gender, data = social_media_clean)

# ANOVA
aov(gad7_total ~ academic_year, data = social_media_clean)

# Regression
lm(gad7_total ~ hours_social_media + age, data = social_media_clean)

Courses to consider:

• PSY 420: Advanced Statistics
• STAT 510: Applied Regression
• Online: Learning Statistics with R

This is the most natural next step for psych majors. Emphasize that the code syntax is nearly identical to what they learned in Session 17 – t.test, aov, and lm all follow the same formula syntax. If students are taking PSY 420 or a stats course next, they’ll already know the R side.

Writing functions

Automate repetitive tasks:

# Instead of copying this code multiple times...
compute_scale_score <- function(data, items) {
  data |>
    rowwise() |>
    mutate(score = mean(c_across(all_of(items)), na.rm = TRUE)) |>
    ungroup()
}

# Use it anywhere
phq9_scored <- compute_scale_score(my_data, c("phq1", "phq2", "phq3"))

Version control with Git

Track changes to your code over time:

• Never lose work — full history of changes
• Collaborate easily — merge changes from multiple people
• Professional standard — expected in industry and academia

Resources:

• Happy Git with R
• GitHub Learning Lab

Interactive visualizations with Shiny

Create web apps for your data:

library(shiny)

ui <- fluidPage(
  selectInput("condition", "Choose condition:", choices = c("CBT", "Control")),
  plotOutput("plot")
)

server <- function(input, output) {
  output$plot <- renderPlot({
    data |> filter(condition == input$condition) |> ggplot(...)
  })
}

shinyApp(ui, server)

Shiny is the most visually exciting “what’s next” option. If you have a Shiny app example you can show briefly, that makes a big impact. Students are often surprised that you can build interactive web apps entirely in R without knowing HTML or JavaScript. Keep it to ~1 minute – just enough to spark curiosity.

Machine learning with tidymodels

Predictive modeling with tidy syntax:

library(tidymodels)

# Split data
data_split <- initial_split(social_media_clean)
train_data <- training(data_split)
test_data <- testing(data_split)

# Fit model
lm_fit <- linear_reg() |>
  fit(gad7_total ~ hours_social_media + age, data = train_data)

# Make predictions
predict(lm_fit, test_data)

Learning resources

Free online resources

Books:

• R for Data Science (2e) — your textbook
• Learning Statistics with R
• Advanced R
• ggplot2: Elegant Graphics for Data Analysis

Interactive learning:

• Posit Primers
• R-Bootcamp
• swirl — learn R in R

Community resources

Weekly challenges:

• #TidyTuesday — practice data viz
• Advent of Code — programming puzzles

Communities:

• R-Ladies — inclusive R community
• R for Data Science Slack
• Posit Community
• Local R user groups (search Meetup.com)

Keep practicing

The only way to maintain skills: use them

Ideas:

• Analyze data from your own research
• Replicate figures from published papers
• Join #TidyTuesday
• Help friends/labmates with their data
• Create a personal website with Quarto
• Build a data visualization portfolio

Tip

Aim for 1 hour per week — consistency matters more than intensity

The “1 hour per week” tip is the most actionable takeaway from this section. Skills decay fast without practice, but even a small amount of regular use keeps them sharp. TidyTuesday is the best recommendation for students who want structure – it provides a new dataset every week with a community sharing their visualizations. Encourage students to pick one or two ideas from this list, not all of them.

Final reflections

What makes a good data scientist?

It’s not about knowing every function or memorizing syntax.

Good data scientists:

1. Ask good questions — what story is the data telling?
2. Stay curious — always learning new tools and techniques
3. Communicate clearly — make complex findings accessible
4. Work reproducibly — others can verify and build on your work
5. Think critically — question assumptions, check for bias
6. Persist through errors — debugging is part of the job

You’ve developed all of these skills this quarter.

This is the emotional core of the closing section. Slow down here. Read through the six qualities and pause on each one. The last line – “You’ve developed all of these skills this quarter” – should land. Students often don’t realize how much they’ve grown because it happened gradually. Connecting each quality back to specific class moments makes it concrete: “Remember when you debugged your partner’s code? That’s persistence.”

The growth mindset

Ten weeks ago, many of you had never written a line of code.

Now you can:

• Import and clean messy data
• Create publication-quality visualizations
• Wrangle complex datasets with joins and pivots
• Handle missing data appropriately
• Build reproducible reports

That’s incredible growth.

Let the bullet list build slowly. Each skill maps to a specific part of the course. Students may not feel like they “mastered” everything, and that’s fine – emphasize that they can do all of these things, even if they still need to look things up. Looking things up is what professionals do too. The phrase “That’s incredible growth” is genuine – let it land before moving on.

Errors are part of the process

Remember:

• Everyone gets errors — even experienced programmers
• Errors mean you’re learning
• Each error you solve makes you better
• The frustration is temporary; the skills are permanent

Important

If you take one thing from this course: You can learn hard things.

This is the single most important message of the course. Many students came in believing they “aren’t math people” or “can’t code.” They now have evidence that they can. The callout box should be the emotional peak of the session. Pause after it. Let the room be quiet for a moment.

Thank you

Thank you for:

• Showing up and participating
• Helping each other
• Asking questions
• Persisting through challenges
• Trusting the process

You’ve been a great class. I’m excited to see what you do with these skills.

Final project presentations

Presentation guidelines

Format: 5 minutes per person

What to include:

1. Research question (1 min)
2. Dataset description (1 min)
3. Key finding with visualization (2 min)
4. Implications/what you learned (1 min)

Tips:

• Show 1-2 of your best figures
• Focus on the story, not technical details
• Practice timing!

Presentations happen during finals week, not today. Go through the format and timing quickly. Emphasize that 5 minutes goes fast – students should practice timing at home. The key message: show your best 1-2 figures and tell the story. Don’t try to explain every line of code. The audience wants to hear the finding, not the data wrangling.

Presentation order

We’ll go alphabetically by last name.

Remember:

• This is a supportive environment
• Everyone is nervous — that’s normal
• We want to hear about your work
• Questions are signs of interest, not criticism

Course evaluations

Please fill out course evaluations

Your feedback helps me improve the course for future students.

What’s helpful:

• Specific examples (this assignment, that lecture)
• Constructive suggestions
• What worked well (so I keep doing it)
• What didn’t work (so I can change it)

I read every evaluation carefully.

Give students 5-10 minutes in class to fill out evaluations. They’re much more likely to complete them if given dedicated class time. Step out of the room or move to the back – students give more honest feedback when the instructor isn’t watching. Set a timer so you know when to come back.

Final words

Keep learning

The field of data science is constantly evolving:

• New packages are released every day
• Best practices change
• Tools improve

Stay curious. Stay connected. Keep coding.

You’re now a data scientist

You have the skills to:

• Answer questions with data
• Create compelling visualizations
• Conduct reproducible research
• Teach yourself new tools

Use them.

Make psychology more reproducible, transparent, and data-driven.

This is the aspirational close. The call to action – “Make psychology more reproducible, transparent, and data-driven” – connects back to Session 1’s opening about the replication crisis. The course has come full circle: they started by learning why data science matters for psychology, and they end with the skills to actually do something about it.

Final final words

Thank you!

Good luck with your final projects and future data science adventures!

Stay in touch:

• ?var:instructor.email
• Office hours (through finals week)

Now let’s see your final projects! 🎉