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. Final project videos are due during finals week, so today is about closing the loop. 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 real dataset together — the General Social Survey, included in forcats as gss_cat.

Research question: Does age predict daily TV viewing among Americans — and does it differ by political party?

I’ll demonstrate the full workflow:

1. Import and explore a real dataset
2. Clean and recode categories
3. Look at distributions (univariate & by group)
4. Quantify the relationship (correlation + regression)
5. Reshape with pivots and joins
6. Build a Quarto report

This live demo is the heart of the lecture (~25-30 minutes). The dataset is real, public, and built into tidyverse – no download, no install. The research question is deliberately ordinary: it’s the kind of question a psych undergrad could answer for a class paper. As you walk through, name the session each step came from – this is the explicit “putting it all together” payoff. If time allows, live-code in RStudio alongside the slides.

The dataset

gss_cat is a sample of the General Social Survey (NORC at the University of Chicago), one of the longest-running social surveys in the US.

gss_cat

# A tibble: 21,483 × 9
    year marital         age race  rincome        partyid    relig denom tvhours
   <int> <fct>         <int> <fct> <fct>          <fct>      <fct> <fct>   <int>
 1  2000 Never married    26 White $8000 to 9999  Ind,near … Prot… Sout…      12
 2  2000 Divorced         48 White $8000 to 9999  Not str r… Prot… Bapt…      NA
 3  2000 Widowed          67 White Not applicable Independe… Prot… No d…       2
 4  2000 Never married    39 White Not applicable Ind,near … Orth… Not …       4
 5  2000 Divorced         25 White Not applicable Not str d… None  Not …       1
 6  2000 Married          25 White $20000 - 24999 Strong de… Prot… Sout…      NA
 7  2000 Never married    36 White $25000 or more Not str r… Chri… Not …       3
 8  2000 Divorced         44 White $7000 to 7999  Ind,near … Prot… Luth…      NA
 9  2000 Married          44 White $25000 or more Not str d… Prot… Other       0
10  2000 Married          47 White $25000 or more Strong re… Prot… Sout…       3
# ℹ 21,473 more rows

The GSS has been running since 1972 and is a backbone dataset in sociology and political psychology. The version bundled with forcats covers 2000-2014 and 21,483 respondents. Highlight that this is real data – the kind their grad school mentors actually use.

Step 1: Explore the data

glimpse(gss_cat)

Rows: 21,483
Columns: 9
$ year    <int> 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 20…
$ marital <fct> Never married, Divorced, Widowed, Never married, Divorced, Mar…
$ age     <int> 26, 48, 67, 39, 25, 25, 36, 44, 44, 47, 53, 52, 52, 51, 52, 40…
$ race    <fct> White, White, White, White, White, White, White, White, White,…
$ rincome <fct> $8000 to 9999, $8000 to 9999, Not applicable, Not applicable, …
$ partyid <fct> "Ind,near rep", "Not str republican", "Independent", "Ind,near…
$ relig   <fct> Protestant, Protestant, Protestant, Orthodox-christian, None, …
$ denom   <fct> "Southern baptist", "Baptist-dk which", "No denomination", "No…
$ tvhours <int> 12, NA, 2, 4, 1, NA, 3, NA, 0, 3, 2, NA, 1, NA, 1, 7, NA, 3, 3…

Emphasize that the first thing to do with any dataset is glimpse(). It tells you the dimensions, variable names, and types – everything you need to orient yourself.

Step 1 (cont.): Check for missing data

gss_cat |>
  summarize(across(everything(), ~sum(is.na(.x))))

# A tibble: 1 × 9
   year marital   age  race rincome partyid relig denom tvhours
  <int>   <int> <int> <int>   <int>   <int> <int> <int>   <int>
1     0       0    76     0       0       0     0     0   10146

Ask: “What do you notice? Which variables have a lot of NAs? Which have none?” tvhours has the most because the question wasn’t asked every year. This connects directly back to Session 14 on missing data.

What’s in partyid?

Before we recode, let’s see what’s actually there:

gss_cat |>
  count(partyid)

# A tibble: 10 × 2
   partyid                n
   <fct>              <int>
 1 No answer            154
 2 Don't know             1
 3 Other party          393
 4 Strong republican   2314
 5 Not str republican  3032
 6 Ind,near rep        1791
 7 Independent         4119
 8 Ind,near dem        2499
 9 Not str democrat    3690
10 Strong democrat     3490

Always check the levels of a categorical variable before recoding it. Students often assume the values they expect; the data has 10 levels including ‘No answer’, ‘Don’t know’, and ‘Other party’. Point out that ‘Ind,near rep’ and ‘Ind,near dem’ are leaners – we’ll group them with Independents in the next step. This habit (count() before case_when()) prevents the most common recoding bug: typos in the lookup strings silently producing NAs.

Step 2: Clean the data

gss_clean <- gss_cat |>
  drop_na(tvhours, age) |>
  mutate(
    party = case_when(
      partyid %in% c("Strong republican", "Not str republican") ~ "Republican",
      partyid %in% c("Strong democrat", "Not str democrat")     ~ "Democrat",
      partyid %in% c("Ind,near rep", "Independent", "Ind,near dem") ~ "Independent",
      TRUE ~ NA_character_
    ),
    party = factor(party, levels = c("Democrat", "Independent", "Republican"))
  ) |>
  drop_na(party)

Walk through each cleaning decision. “Why drop_na on tvhours and age?” Because we can’t analyze missing values. “Why collapse partyid into three categories?” Because the raw variable has 10 levels including ‘Don’t know’ and ‘No answer’ – too granular to plot. We’re treating ‘near rep’ and ‘near dem’ leaners as Independents for simplicity. Each of these decisions maps to a session: drop_na (Session 14), case_when (Session 4), factor levels (Session 12).

Step 3: Descriptive statistics

gss_clean |>
  summarize(
    n = n(),
    mean_age = mean(age),
    mean_tv = mean(tvhours),
    sd_tv = sd(tvhours)
  )

# A tibble: 1 × 4
      n mean_age mean_tv sd_tv
  <int>    <dbl>   <dbl> <dbl>
1 11026     47.2    2.98  2.57

Step 3 (cont.): Group sizes

gss_clean |>
  count(party)

# A tibble: 3 × 2
  party           n
  <fct>       <int>
1 Democrat     3832
2 Independent  4461
3 Republican   2733

Step 4: How much TV do people watch?

Start with univariate EDA — one variable at a time.

ggplot(gss_clean, aes(x = tvhours)) +
  geom_histogram(binwidth = 1, fill = "steelblue", color = "white") +
  labs(
    title = "Most respondents watch 1-3 hours per day",
    subtitle = "But the tail stretches to 24 hours",
    x = "Hours of TV per day",
    y = "Number of respondents"
  ) +
  theme_minimal()

This is Session 10 territory – look at the shape of one variable before anything else. The distribution is right-skewed with a peak at 2 hours and a tail of heavy viewers. Ask: “What kinds of people might be in that tail?” The skew matters because mean > median when data is skewed – a chance to remind them why we often prefer the median for skewed data.

Step 4: How much TV do people watch?

Step 4 (cont.): Does it differ by party?

Now bivariate EDA — compare distributions across groups.

ggplot(gss_clean, aes(x = party, y = tvhours, fill = party)) +
  geom_boxplot(alpha = 0.7) +
  scale_fill_manual(values = c(
    "Democrat"    = "#3498db",
    "Independent" = "#7f8c8d",
    "Republican"  = "#e74c3c"
  )) +
  labs(
    title = "TV viewing distributions look similar across parties",
    x = NULL,
    y = "Hours of TV per day"
  ) +
  theme_minimal() +
  theme(legend.position = "none")

Session 11 – covariation between a categorical and a continuous variable. The boxplot is the workhorse for “does this group matter for that number?” Point out the medians (the bold line inside the box), the IQR (box height), and the outliers (dots). Quick check: medians look similar across parties, so party probably won’t be a big driver in our model.

Step 4 (cont.): Does it differ by party?

Step 5: Initial visualization

ggplot(gss_clean, aes(x = age, y = tvhours)) +
  geom_jitter(alpha = 0.15, height = 0.3, width = 0) +
  geom_smooth(method = "lm", color = "steelblue") +
  labs(
    title = "Older Americans report more daily TV viewing",
    subtitle = "General Social Survey, 2000-2014",
    x = "Age (years)",
    y = "Hours of TV per day"
  ) +
  theme_minimal()

Step 5: Initial visualization

Step 6: Compute correlation

cor_value <- cor(gss_clean$age, gss_clean$tvhours)
cor_value

[1] 0.1424147

Finding: A small but reliable positive correlation (r = 0.14).

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 r ≈ 0.14 mean in real terms?” Students who were in Session 17 should be able to answer this. Worth noting: with N this large, even tiny correlations are ‘statistically significant’ – a great chance to remind them that effect size matters more than p-values.

Step 7: Run a regression

A correlation gives one number. A regression gives a slope — how much does TV viewing change per year of age?

tv_model <- lm(tvhours ~ age + party, data = gss_clean)

library(broom)
tidy(tv_model)

# A tibble: 4 × 5
  term             estimate std.error statistic   p.value
  <chr>               <dbl>     <dbl>     <dbl>     <dbl>
1 (Intercept)        2.24     0.0795      28.2  5.22e-169
2 age                0.0212   0.00140     15.2  2.17e- 51
3 partyIndependent  -0.262    0.0562      -4.67 2.99e-  6
4 partyRepublican   -0.618    0.0635      -9.73 2.69e- 22

Direct callback to Session 17. The lm() formula syntax (y ~ x1 + x2) is the foundation for almost all R modeling – t-tests, ANOVA, mixed models, even Bayesian models use the same notation. broom::tidy() turns the messy summary() output into a tidy tibble we can pipe and plot. Walk through the estimate column: the age slope tells us about how many additional minutes of TV per year of age.

Step 7 (cont.): How well does it fit?

glance(tv_model) |>
  select(r.squared, adj.r.squared, sigma, nobs)

# A tibble: 1 × 4
  r.squared adj.r.squared sigma  nobs
      <dbl>         <dbl> <dbl> <int>
1    0.0286        0.0284  2.54 11026

R² is tiny — age and party explain only a small slice of TV viewing. The story isn’t wrong, it just isn’t the whole story.

glance() gives one-row model summaries; tidy() gives one row per coefficient. Together they’re the broom workflow. The small R² is the right teaching moment: “statistically significant” ≠ “explains a lot.” Pair this with the earlier note about effect size. This also makes the case for multivariate models in PSY 420 – we’re not capturing the variables that really matter (income, education, screen-time substitution, etc.).

Step 8: Does the pattern differ by party?

ggplot(gss_clean, aes(x = age, y = tvhours, color = party)) +
  geom_smooth(method = "lm") +
  scale_color_manual(values = c(
    "Democrat"    = "#3498db",
    "Independent" = "#7f8c8d",
    "Republican"  = "#e74c3c"
  )) +
  labs(
    title = "Same pattern across the political spectrum",
    x = "Age (years)",
    y = "Hours of TV per day",
    color = "Party"
  ) +
  theme_minimal() +
  theme(legend.position = "top")

Step 8: Does the pattern differ by party?

Step 9: TV viewing categories

gss_clean |>
  mutate(
    tv_category = case_when(
      tvhours == 0 ~ "None",
      tvhours <= 2 ~ "Light (1-2 hr)",
      tvhours <= 4 ~ "Moderate (3-4 hr)",
      tvhours >= 5 ~ "Heavy (5+ hr)"
    ),
    tv_category = factor(tv_category,
                         levels = c("None", "Light (1-2 hr)",
                                    "Moderate (3-4 hr)", "Heavy (5+ hr)"))
  ) |>
  count(tv_category) |>
  ggplot(aes(x = n, y = fct_rev(tv_category), fill = tv_category)) +
  geom_col() +
  scale_fill_manual(values = c(
    "None"              = "#2ecc71",
    "Light (1-2 hr)"    = "#f39c12",
    "Moderate (3-4 hr)" = "#e67e22",
    "Heavy (5+ hr)"     = "#e74c3c"
  )) +
  labs(
    title = "Most Americans watch 1-4 hours of TV per day",
    x = "Number of respondents",
    y = NULL
  ) +
  theme_minimal() +
  theme(legend.position = "none")

Step 9: TV viewing categories

Step 10: Has TV viewing changed over time?

gss_clean |>
  group_by(year) |>
  summarize(mean_tv = mean(tvhours), .groups = "drop") |>
  ggplot(aes(x = year, y = mean_tv)) +
  geom_line(color = "steelblue", linewidth = 1.2) +
  geom_point(color = "steelblue", size = 3) +
  labs(
    title = "Mean daily TV viewing across GSS years",
    x = "Survey year",
    y = "Mean hours of TV per day"
  ) +
  theme_minimal()

This is a grouped summary feeding straight into a plot – a pattern they’ll use constantly. Note how group_by() |> summarize() collapses 21,000 rows into 8. The line plot is intuitive for time series. Ask: “What might explain a downward drift in TV hours over this period?” (Streaming, YouTube, social media displacing traditional TV.)

Step 10: Has TV viewing changed over time?

Step 11: Add political context with a join

What if we want to label each year by who was president? We need a second table, then a join (Session 15).

president_lookup <- tribble(
  ~year, ~president,
   2000, "Clinton",
   2002, "G.W. Bush",
   2004, "G.W. Bush",
   2006, "G.W. Bush",
   2008, "G.W. Bush",
   2010, "Obama",
   2012, "Obama",
   2014, "Obama"
)

president_lookup

# A tibble: 8 × 2
   year president
  <dbl> <chr>    
1  2000 Clinton  
2  2002 G.W. Bush
3  2004 G.W. Bush
4  2006 G.W. Bush
5  2008 G.W. Bush
6  2010 Obama    
7  2012 Obama    
8  2014 Obama    

tribble() is the row-by-row tibble constructor – nice for small lookups like this. The next slide does the actual join. Frame the join as “add columns from another table by matching on a key.” The key here is year.

Step 11 (cont.): The join

gss_with_president <- gss_clean |>
  left_join(president_lookup, by = "year")

gss_with_president |>
  group_by(president) |>
  summarize(
    n = n(),
    mean_tv = mean(tvhours),
    .groups = "drop"
  ) |>
  arrange(desc(mean_tv))

# A tibble: 3 × 3
  president     n mean_tv
  <chr>     <int>   <dbl>
1 Obama      4245    3.02
2 Clinton    1799    2.99
3 G.W. Bush  4982    2.95

Tiny differences — but the technique is what counts. Joins let you bring in any external data (codebooks, demographics, neighborhood stats).

Big caveat: this is correlation, not causation. TV viewing didn’t change because the president changed. The point is the mechanic of the join, plus arrange(desc(...)) to sort. Real psych use: joining survey responses with demographics, or wave 1 with wave 2 of a longitudinal study.

Step 12: Summary table by party

summary_table <- gss_clean |>
  group_by(party) |>
  summarize(
    N        = n(),
    Mean_Age = mean(age),
    Mean_TV  = mean(tvhours),
    SD_TV    = sd(tvhours),
    .groups  = "drop"
  )

knitr::kable(summary_table, digits = 1,
             col.names = c("Party", "N", "M Age", "M TV", "SD TV"))

Party	N	M Age	M TV	SD TV
Democrat	3832	48.7	3.3	2.8
Independent	4461	44.8	2.9	2.6
Republican	2733	49.2	2.7	2.2

Step 13: Write it up in Quarto

## Results

We analyzed data from `r nrow(gss_clean)` respondents in
the General Social Survey (2000-2014), with a mean age of
`r round(mean(gss_clean$age), 1)` years. Respondents reported
watching `r round(mean(gss_clean$tvhours), 1)` hours of TV per
day on average (SD = `r round(sd(gss_clean$tvhours), 1)`).

Age was positively correlated with daily TV viewing
(r = `r round(cor_value, 2)`), such that older respondents
tended to report more hours of TV.

The inline R expressions (the backtick-r bits) are the magic. They evaluate at render time, so the numbers in the prose are pulled live from the data. No hand-typed numbers; no copy-paste from console output. If the data changes, the writeup updates automatically. Next slide shows what this renders to.

Step 13 (cont.): What it renders to

Results

We analyzed data from 11026 respondents in the General Social Survey (2000-2014), with a mean age of 47.2 years. Respondents reported watching 3 hours of TV per day on average (SD = 2.6).

Age was positively correlated with daily TV viewing (r = 0.14), such that older respondents tended to report more hours of TV. The relationship was similar across Democrats, Independents, and Republicans.

This is the same prose from the previous slide, but rendered. Point at the numbers and say “every one of these came from the data via inline R.” If you change the dataset (add rows, drop a year), every number updates on re-render. This is what ‘reproducible’ actually buys you.

What this demonstrates

• ✅ Explore & clean — glimpse, count, case_when, drop_na, factor
• ✅ Univariate & bivariate EDA — geom_histogram, geom_boxplot
• ✅ Quantify — cor, lm, broom::tidy, broom::glance
• ✅ Group & reshape — group_by, summarize, tribble, left_join, arrange
• ✅ Visualize — scatter, line, bar, box; color, scale, theme, labs
• ✅ Communicate — kable tables + inline R in Quarto

One pipeline. Sixteen sessions of skills.

This is the payoff slide. Read each line and name the session it came from. The closing line should land – they’ve genuinely used skills from nearly every session in one connected analysis. 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 (1/2)

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

Ask students: “Which of these have you gotten this quarter?” Hands will go up for all three. The most common 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.

The 6 errors you’ll see most often (2/2)

Error	What it means	Fix
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 +

The bottom three are operator and syntax errors. The “did you mean ==” error is friendly – R is literally telling you the fix. The ggplot + error is a classic Session 2 issue that still trips students up; remind them ggplot uses + between layers, not |>.

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

Tip

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

library(tidyverse)

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

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

Time: 10 minutes

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.

Before we move on

📤 Submit your code on Canvas for participation credit. Paste what you have — 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
• Writing functions — automate repetitive work
• Version control — Git and GitHub
• Interactive tools — Shiny dashboards
• The wider R ecosystem — tidymodels, tidytext, and more

Statistics in R

You can now learn inferential statistics:

# t-test (compare two groups)
t.test(tvhours ~ I(party == "Republican"), data = gss_clean)

# ANOVA (compare multiple groups)
aov(tvhours ~ party, data = gss_clean)

# Regression
lm(tvhours ~ age + party, data = gss_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

Build web apps for your data — no HTML or JavaScript required:

library(shiny)

ui <- fluidPage(
  selectInput("party", "Choose party:",
              choices = c("Democrat", "Independent", "Republican")),
  plotOutput("plot")
)

server <- function(input, output) {
  output$plot <- renderPlot({
    gss_clean |>
      filter(party == input$party) |>
      ggplot(aes(age, tvhours)) + geom_point()
  })
}

shinyApp(ui, server)

See Shiny in action

Posit’s classic Movie Explorer — try the sliders and dropdowns.

This is Posit’s canonical Shiny demo. Let students poke at it for 30-60 seconds. Point out the live filtering – every change updates the plot without reloading. The entire app is ~50 lines of R. After class, students can browse the full gallery at shiny.posit.co/r/gallery for more examples. If the iframe doesn’t load (network/firewall), open the link directly in a browser.

Go deeper into the R ecosystem

The R world is huge. A few doorways worth knowing:

Modeling:

• tidymodels — predictive modeling with tidy syntax
• brms — Bayesian regression
• lme4 — mixed-effects models

Text & language:

• tidytext — turn text into tidy data (you’ve seen this)
• ellmer — call LLMs (Claude, GPT) from R

Don’t go deep on any of these – the point is to show that R has a thoughtful, well-built package for almost every task they’ll encounter. tidymodels is the natural next step for anyone interested in prediction or machine learning. ellmer is brand new and worth mentioning because LLM workflows are increasingly part of research.

Go deeper (cont.): communication & workflow

Communication:

• gtsummary — publication-ready summary tables
• quarto — websites, books, dashboards (you’ve used the basics)

Workflow:

• targets — reproducible analysis pipelines
• renv — project-level package management

gtsummary is the single biggest time-saver for anyone writing a thesis or paper – it produces APA-style descriptives in one call. targets and renv are about making analyses survive over time: targets caches expensive computations so you don’t re-run them, and renv pins your package versions so the analysis still works two years later. Encourage them to bookmark this slide.

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. 🎉