R: mtcars regression + inline plots¶

A pure-R notebook — every cell is R. Load the built-in mtcars dataset, summarise it, fit a linear model, and draw two plots that render inline as PNG. Variables flow cell-to-cell through the same content-addressed artifact store the Python cells use; here both ends of every edge happen to be R.

What it shows¶

R cells stand on their own. No Python anywhere. The DAG, the provenance cache, and the cascade all work exactly as they do for Python — language is per-cell, not per-notebook.
Inline plots (0.2.0). A ggplot scatter and R's base-graphics 2×2 plot(lm) diagnostic panel both render as PNG in the cell, just like a Python matplotlib figure. A bare trailing ggplot object auto-prints — no explicit print().
Two kinds of R→R handoff. data.frames (cars, by_cyl) cross as Arrow IPC. The lm object itself isn't tabular, so it's stored as RDS (r_only) and read straight back by the diagnostics cell with full fidelity — an R-only object flowing between R cells that the Arrow tier couldn't carry. (A Python cell consuming it would get a structured "re-export as a data.frame" error instead of a crash.)
renv, one click. The plotting cell needs ggplot2, which isn't in the harness baseline. It's pinned in renv.lock and restored automatically when you open the notebook — or via the Environment panel's Initialize renv. A missing package surfaces a structured install hint, not a stack trace.

Cells¶

Cell	What it does
`prep`	Tidy `mtcars` into a `data.frame` (`cars`) — model name column, `cyl` as a factor.
`summarise`	`aggregate()` mean mpg / hp / wt by cylinder count → `by_cyl`.
`fit`	`lm(mpg ~ wt + hp + cyl)`; emit the `model` (RDS), a tidy `coefs` table, and one-row `model_stats`.
`plot-mpg`	ggplot2 scatter of mpg vs weight, coloured by cylinder, with per-group fits → inline PNG.
`diagnostics`	Read `model` back from RDS; base-graphics 2×2 residual diagnostics → inline PNG.

What you need¶

R on PATH (Rscript). The notebook's arrow, jsonlite, and ggplot2 come from renv.lock — opening the notebook restores them into a project-scoped library automatically; no system installs beyond R itself.
The uv-managed Python venv carries only the notebook harness baseline (pyarrow / orjson / cloudpickle); no Python runs any cell here.

Running¶

From the project root:

uv run strata-notebook --host 127.0.0.1 --port 8765

Open examples/r_mtcars_analysis from the Strata home page and run the cells top to bottom. Or run it headlessly — strata run executes R cells and restores the notebook's renv.lock on the way in:

uv run strata run examples/r_mtcars_analysis

Try this¶

Swap in another plot. Replace plot-mpg with ggplot(by_cyl, aes(factor(cyl), mean_mpg)) + geom_col() — a bar of mean economy by cylinder. Edit, Shift+Enter, watch it re-render.
Reach a non-tabular object across cells. Add a cell with confint(model) — model resolves from the RDS artifact and you get coefficient confidence intervals, no re-fit.
Break, then fix, the environment. Delete the renv/ directory and reopen: the ggplot cell shows the install hint; click Initialize renv (or Install ggplot2) and re-run.

Prepare the mtcars data¶

_{kind r}

# @name Prepare the mtcars data
#
# A pure-R notebook — every cell is R. Variables flow cell-to-cell
# through the same content-addressed artifact store the Python cells
# use: a data.frame crosses as Arrow IPC, so the next R cell receives
# it as a data.frame with no glue code.
#
# `mtcars` ships with R (1974 Motor Trend, 32 cars). Tidy it into the
# frame the rest of the notebook builds on: keep the model name as a
# real column, make the cylinder count a factor (so the model and the
# plots treat it as categorical), and keep the columns we care about.

cars <- data.frame(
  model = rownames(mtcars),
  mpg = mtcars$mpg,
  wt = mtcars$wt,
  hp = mtcars$hp,
  cyl = factor(mtcars$cyl),
  row.names = NULL
)

cat(sprintf(
  "Prepared %d cars across %d cylinder classes (%s)\n",
  nrow(cars), nlevels(cars$cyl), paste(levels(cars$cyl), collapse = ", ")
))

Summarise by cylinder count¶

_{kind r}

# @name Summarise by cylinder count
#
# Split-apply-combine in base R: group the cars by cylinder class and
# average economy, power, and weight per group. `aggregate()` is the
# base-R group-by — no dplyr needed. `cars` arrives as a data.frame
# (the Arrow IPC handoff from the prep cell), and `by_cyl` leaves as
# one too, ready for any downstream cell.

by_cyl <- aggregate(
  cbind(mpg, hp, wt) ~ cyl,
  data = cars,
  FUN = mean
)
by_cyl$n <- as.integer(table(cars$cyl))
names(by_cyl) <- c("cyl", "mean_mpg", "mean_hp", "mean_wt", "n")

print(by_cyl)

Fit mpg ~ wt + hp + cyl¶

_{kind r}

# @name Fit mpg ~ wt + hp + cyl
#
# R's formula syntax in one line: predict mpg from weight, horsepower,
# and the cylinder factor (auto dummy-encoded, 4-cyl as the baseline
# level). Three outputs leave this cell with three different fates in
# the artifact store:
#
#   model        — the lm object itself. Not tabular, so the harness
#                  stores it as RDS and tags it `r_only`. A downstream
#                  *R* cell reads it straight back with readRDS (see the
#                  diagnostics cell); a Python cell consuming it would
#                  instead get a structured "re-export as a data.frame"
#                  error rather than a confusing NameError.
#   coefs        — tidy coefficient table (data.frame -> Arrow IPC).
#   model_stats  — one-row fit summary (data.frame -> Arrow IPC).

model <- lm(mpg ~ wt + hp + cyl, data = cars)
s <- summary(model)

cm <- s$coefficients
coefs <- data.frame(
  term = rownames(cm),
  estimate = cm[, "Estimate"],
  std_error = cm[, "Std. Error"],
  t_stat = cm[, "t value"],
  p_value = cm[, "Pr(>|t|)"],
  row.names = NULL
)

model_stats <- data.frame(
  r_squared = s$r.squared,
  adj_r_squared = s$adj.r.squared,
  sigma = s$sigma,
  df_residual = model$df.residual
)

cat(sprintf(
  "Fitted mpg ~ wt + hp + cyl: R2=%.3f (adj %.3f), residual SE=%.2f mpg\n",
  model_stats$r_squared, model_stats$adj_r_squared, model_stats$sigma
))

Plot mpg vs weight (ggplot2)¶

_{kind r}

# @name Plot mpg vs weight (ggplot2)
#
# The headline 0.2.0 R feature: plots render inline as PNG, exactly
# like a Python matplotlib figure. A bare trailing ggplot object
# auto-prints (REPL-style), so no explicit `print()` is needed — the
# plot is the cell's last expression and it just shows up.
#
# ggplot2 isn't part of the harness baseline (arrow + jsonlite); it
# comes from this notebook's renv.lock, restored automatically when you
# open the notebook — or one click via the Environment panel's
# "Initialize renv". If it's somehow missing you'll see a structured
# "install ggplot2" hint, not a crash.

library(ggplot2)

ggplot(cars, aes(x = wt, y = mpg, colour = cyl)) +
  geom_point(size = 3, alpha = 0.85) +
  geom_smooth(method = "lm", formula = y ~ x, se = FALSE, linewidth = 0.7) +
  labs(
    title = "Fuel economy falls with weight",
    subtitle = "mtcars, coloured by cylinder count",
    x = "Weight (1000 lbs)",
    y = "Miles per gallon",
    colour = "Cylinders"
  ) +
  theme_minimal(base_size = 13)

Residual diagnostics (base graphics)¶

_{kind r}

# @name Residual diagnostics (base graphics)
#
# `plot()` on an lm object draws R's canonical 2x2 diagnostic panel
# (residuals vs fitted, Q-Q, scale-location, residuals vs leverage).
# It's a base-graphics plot, and it's captured to PNG the same way the
# ggplot is — no extra code, no device juggling. `par(mfrow)` tiles the
# four panels onto one image.
#
# `model` arrives by reading the RDS artifact the fit cell stored: an
# R-only object (an lm, S3 class and all) flowing from one R cell to
# another with full fidelity — something the tabular Arrow tier can't
# carry. This is the R-to-R counterpart of the cross-language Arrow
# handoff.

op <- par(mfrow = c(2, 2), mar = c(4, 4, 2, 1))
plot(model)
par(op)