🛟 Help

Three ways to run course code, from zero-install to full local setup. The course doesn't grade you on your IDE — pick the one that gets out of your way.

Already live in RStudio Desktop, VS Code, or Jupyter? They all work fine too — no need to switch mid-habit.

1 · Install R

Download from CRAN: cran.r-project.org — pick your OS, run the installer, accept the defaults. (Skip this on Posit Cloud; R is already there.) Then open Positron and let it discover your R install.

2 · Install the course packages

In the R console:

install.packages(c("dplyr", "ggplot2", "readr", "tidyr", "broom", "moments"))

That covers most chapters; each chapter's meta row lists anything extra, and you install those as you meet them. House style note: we load packages individually — library(dplyr), library(ggplot2) — never library(tidyverse).

3 · Verify with the "hello, sigma" snippet

Three lines that prove the language, the pipeline packages, and plotting all work. Paste and run:

# a quick process sample + histogram
library(dplyr)
library(ggplot2)
obs = tibble(x = rnorm(100, mean = 5, sd = 1))
obs %>% ggplot(aes(x = x)) + geom_histogram()
cat("hello, sigma!", nrow(obs), "observations\n")

If a histogram appears and hello, sigma! 100 observations prints, you're set. Copy chunk code straight out of any chapter page — every code block has a copy button.

Windows note: if a package won't compile, install Rtools and retry — though the precompiled CRAN binaries usually just work.

1 · Install Python (3.10+)

• uv (recommended) — github.com/astral-sh/uv: a modern, fast Python + package installer.
• python.org installer — straight from python.org/downloads; click through.
• conda / miniforge — if you already use it.

Then open Positron and pick your Python interpreter when prompted.

2 · Install the course packages

In your terminal (not inside Python):

pip install pandas plotnine numpy scipy statsmodels

(or uv pip install …, which is faster and handles proxies more gracefully). Chapters use pandas + plotnine throughout; a chapter's meta row lists its exact packages.

3 · Verify with the "hello, sigma" snippet

# a quick process sample + histogram
import numpy as np
import pandas as pd
from plotnine import ggplot, aes, geom_histogram
obs = pd.DataFrame({'x': np.random.normal(5, 1, 100)})
print(ggplot(obs, aes(x = 'x')) + geom_histogram())
print("hello, sigma!", len(obs), "observations")

If something went wrong

• Most common cause: old Python (you need 3.10+) — check with python3 --version.
• Permissions error? pip install --user ….
• And remember: the Playground works with no local install at all — you can use it for the full course if your laptop won't cooperate.

Git is the command-line tool; GitHub is the hosting service. You need Git locally before GitHub becomes useful. Plan on ~30 minutes the first time, two minutes per week after that.

1 · Install Git

• macOS: open Terminal and run git --version. If it prompts you to install Xcode command-line tools, accept. Otherwise you already have it.
• Windows: install Git for Windows. It includes Git Bash, which gives you a Unix-style terminal — keep that box checked.
• Linux: sudo apt install git (Debian/Ubuntu) or your distro's equivalent.

Then tell Git who you are — once per machine:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global init.defaultBranch main

2 · Make a GitHub account

• Sign up at github.com/signup — the free tier is plenty. Use github.com, not a GitHub Enterprise instance (like github.coecis.cornell.edu).
• Use the same email you gave Git above, and pick a username that's recognizably you so classmates and staff can find you.
• Personal Access Token (PAT): you'll need one to push from the command line. Settings → Developer settings → Personal access tokens. A classic token with the repo scope works; pick an expiration past the end of the semester, and save the token in your password manager the moment you see it — GitHub only shows it once. When Git prompts for a password on your first push, paste the PAT.
• Prefer SSH keys? Follow GitHub's SSH guide — the course doesn't care which you pick.

3 · Clone the course code repo

The chapters themselves live on this website. The code and data that go with them live at github.com/timothyfraser/sysen — the workshops/ datasets, the functions/ modules, and the starter scripts. Cloning makes a local copy you can refresh with git pull:

# from the folder where you keep code:
git clone https://github.com/timothyfraser/sysen.git
cd sysen
git pull   # each week, to grab updates

You won't push to this repo — it's read-only for students. The course pushes to you; your own work lives in your own repo.

4 · The whole workflow: add / commit / push

git status                          # 1. see what's changed
git add .                           # 2. stage it
git commit -m "xbar chart: first pass"   # 3. record it
git push                            # 4. send it to GitHub

Commit often, in small chunks, with short messages. They don't need to be poetic — the point is breadcrumbs, so a future you (or a grader) can trace what changed and when. What not to commit: large datasets (>50 MB), credentials (.env, API keys), or editor junk like .Rproj.user/ — add a .gitignore.

Same loop without leaving R / Positron

install.packages(c("usethis", "gert", "credentials"))
credentials::set_github_pat()   # store your PAT in the OS keychain, once
usethis::git_vaccinate()        # protect against committing .env, .Rhistory, ...

# then, per work session:
gert::git_pull()
gert::git_add(dir(all.files = TRUE))
gert::git_commit_all("xbar chart: first pass")
gert::git_push()

From Python there's no equivalent worth recommending — open a terminal in Positron and run the git commands above. That's what most working scientists do regardless of language.

Stuck in vim after git commit?

Press Esc, type :wq, press Enter. Use git commit -m "message" next time to skip the editor.

Updates were rejected because the tip of your branch is behind

Another machine (probably also you) pushed first: git pull --rebase, then git push.

fatal: not a git repository

You're running Git outside an initialized folder — cd into the folder that has the .git directory, or git init if you meant to start one here.

Every chapter has a live code Playground running a real R (WebR) or Python (Pyodide) runtime — nothing to install, nothing to sign in to. It auto-boots in the background as soon as the chapter page renders, before you've even pressed Run.

Why the first run on a new chapter is slower

The runtime downloads and caches the packages that chapter needs the first time you visit. That package cache persists across reloads (browser storage — IndexedDB/CacheStorage), so returning to a chapter, or reloading the page, reuses what's already downloaded instead of re-fetching it.

🧹 Clear cache

If a Playground gets into a bad state (a stale package, a corrupted cache), every chapter's Playground panel has a 🧹 clear cache button. It's a two-click confirm: the first click arms it, the second wipes that playground's saved runtime/package cache and reloads with fresh assets. It only clears runtime/package state — your learning-check answers and justifications are stored separately and are never touched by it.

Do I need R or Python installed to do the readings?

No, the in-page Playground runs a real runtime in your browser. See Playground & cache.

Which track should I pick, R or Python?

Pick whichever you're more comfortable learning; every paired chapter teaches the same concept in both.

My Playground won't run / looks stuck — what do I do?

Try the 🧹 clear cache button first, then reload. If it still fails, see Get unstuck.

Where do I submit my learning checks?

See Assignments → Where to submit.

Where do I find the in-class activities?

Every in-class activity from the slides is collected on the Activities page — expand a card for the instructions and where it gets submitted.

The previous edition of the book and its code repo are kept online exactly as they were, so past students' bookmarks and citations keep working.

• timothyfraser.com/sigma-old — the archived 2025 textbook (the old timothyfraser.com/sigma).
• github.com/timothyfraser/sysen (v2025) — the 2025 version of the sysen code & data repo.

Taking the course now? Use this site — the archive is frozen and won't be updated.

Work through these in order:

1. Check this Help page's FAQ and the Playground & cache section — most stuck-Playground issues are a stale cache.
2. Re-read the chapter's own text and worked Learning Check answers — the fix is often already on the page.
3. Ask on the course's Ed Discussion board — that's the place for questions about course content and coursework, and an answer there reaches everyone else stuck on the same thing.
4. Bring it to office hours — book a slot with Dr. Fraser or the team, and bring the code that isn't working. Who's on the team and when they hold hours is on the Syllabus → Staff & office hours.
5. Email the instructor directly if it's blocking a deadline.