Version Control for Statisticians: A Look at Git Basics

As a statistician, you work with multiple versions of datasets, analysis scripts, and reports. Version control helps you track changes, collaborate with others, and maintain reproducibility in your statistical work. This tutorial introduces Git, focusing on aspects most relevant to statistical workflows.

What is Git?

Git is a distributed version control system that helps you track changes in your files over time. Think of it as a sophisticated system that takes snapshots of your project at different points in time. Unlike simple file backup solutions, Git:

Records the complete history of changes to your files
Allows you to work on different versions of your project simultaneously
Facilitates collaboration by merging changes from multiple people
Enables you to revert to previous versions if something goes wrong
Helps you understand who made what changes, when, and why

Originally created by Linus Torvalds for Linux kernel development, Git has become the standard tool for version control across many disciplines, including data science and statistics.

Why Git for Statisticians?

Reproducibility: Track changes in your R/Python scripts, ensuring you can recreate analyses from any point in time
Collaboration: Work seamlessly with team members on shared statistical projects
Documentation: Maintain a clear history of why certain analytical decisions were made
Backup: Keep your work safe and accessible across multiple machines

Essential Git Concepts

The following commands are executed in a terminal (Command Prompt on Windows, Terminal on macOS/Linux). You can access the terminal directly or through your IDE (like RStudio’s terminal panel). While there are graphical interfaces available for Git, understanding these terminal commands provides a solid foundation and helps you understand what’s happening behind the scenes.

1. Repository (Repo)

A repository is like a project folder that Git monitors. It contains all your project files and their complete history. Let’s create our first repository for a statistical analysis project:

# Navigate to your Desktop
cd Desktop

# Initialize a new Git repository
git init analysis_project

# Move into the new repository
cd analysis_project

This code block creates a new Git repository on your Desktop – think of it as setting up a smart folder that will track all changes to your statistical analysis files. The git init command creates a hidden .git directory that will store all the version history of your project.

2. Basic Project Structure

It’s good practice to set up a clear directory structure for your statistical project:

# Create standard directories for your statistical project
mkdir data
mkdir scripts
mkdir output
mkdir docs

# Create a README file
echo "# Statistical Analysis Project" > README.md

This structure creates separate directories for your data, analysis scripts, output files, and documentation. The README.md file will serve as the main documentation for your project, helping others understand its purpose and organization.

3. Staging and Committing Changes

Now that we have our project structure, let’s understand how Git tracks changes. Git uses a two-step process: staging files (preparing them for saving) and then committing them (actually saving the changes). First, let’s see what Git currently knows about our project:

# Check the status of your repository
git status

This command shows you which files Git is tracking and which have been modified. You’ll see that your README.md file is listed as “untracked files”.

Let’s stage this file for your first commit:

# Add all files in the current directory to staging
git add .

# Check status again to see what's staged
git status

The git add . command tells Git to stage all files in the current directory. You’ll now see your files are “staged for commit” in green.

Now, let’s commit these staged changes with a meaningful message:

# Commit the staged changes with a descriptive message
git commit -m "Initialize project with README.md file."

The -m flag allows you to add a commit message that describes what changes you’re saving. Always make these messages clear and descriptive – they’re like notes to your future self!

4. Creating Your First Analysis Script

Let’s create a simple R script in our project and track it with Git. First, create a new R script file:

# Move into the scripts directory
cd scripts

# Create a new R script (on Windows)
echo # Initial statistical analysis > analysis.R

# Or on macOS/Linux
echo "# Initial statistical analysis" > analysis.R

Now let’s track this new file with Git:

# Stage the new R script
git add analysis.R

# Commit the new file
git commit -m "Add initial R analysis script"

This workflow of making changes, staging them (git add), and committing them (git commit) is the core cycle you’ll use throughout your project.

If you open your analysis.R file within R Studio, you might notice that a .Rhistory file appeared in your directory. This is a session-specific file that tracks your R command history and shouldn’t be version controlled. This brings us to an important concept: telling Git which files to ignore.

5. Ignoring Files

Let’s create a .gitignore file to tell Git which files it should not track. We’ll use the following commands:

# Move back to the project root directory
cd ..

# Create .gitignore and add first line
echo ".Rhistory" > .gitignore

# Append each additional line
echo ".RData" >> .gitignore
echo ".Rproj.user/" >> .gitignore
echo "output/*" >> .gitignore
echo "*.csv" >> .gitignore

# View the contents to verify
cat .gitignore

Note: The > (single arrow head) creates or overwrites the file, while >> (double arrow head) appends to the file. You could also create this file using any text editor you prefer.

This .gitignore file tells Git to ignore R session files, output files, and CSV files. Now let’s add this .gitignore file to Git:

# Stage and commit the .gitignore file
git add .gitignore
git commit -m "Add .gitignore file for R project"

Now when you run git status, you shouldn’t see the .Rhistory file anymore. This keeps your repository clean and focused on the important files: your analysis scripts, documentation, and essential data files.

Understanding Changes in Your Project

Now that we have our basic project structure with a README and an analysis script, let’s see how Git helps us track changes to our files.

1. Making and Viewing Changes

Let’s add some actual content to our R analysis script:

# Move into the scripts directory
cd scripts

# Add content to our analysis file (for Windows)
echo # Load required libraries > analysis.R
echo library(tidyverse) >> analysis.R
echo # Read data >> analysis.R
echo data <- read.csv("../data/mydata.csv") >> analysis.R

# Or for macOS/Linux
echo "# Load required libraries" > analysis.R
echo "library(tidyverse)" >> analysis.R
echo "# Read data" >> analysis.R
echo 'data <- read.csv("../data/mydata.csv")' >> analysis.R

Now let’s see what Git tells us about these changes:

# See what changed in our script
git diff analysis.R

The git diff command shows you what’s changed in your files. Lines with a + were added, and lines with a – were removed.

2. Staging and Committing Changes

# Stage the changes
git add analysis.R

# Commit with a descriptive message
git commit -m "Add data loading code to analysis script"

3. Viewing History

Git keeps a complete history of all your changes. Let’s look at what we’ve done so far:

# View the commit history
git log

The git log command shows all commits in reverse chronological order, including who made the changes and when.

4. Undoing Changes

Sometimes you’ll make changes that you want to undo. Let’s see how to handle this common situation:

# Add a line we'll want to undo
echo "# This is a mistake" >> analysis.R

# View the changes
git status
git diff analysis.R

# Discard changes in analysis.R
git restore analysis.R

# Verify the changes were undone
git status

The git restore command discards changes that haven’t been committed yet, returning the file to its last committed state.

Conclusion

You’ve now learned the essential Git commands for version control in your statistical projects. You can:

Create and structure a Git repository
Track changes to your analysis scripts
Save snapshots of your work with meaningful messages
View the history of your changes
Undo mistakes when they happen

For example, imagine you’re working on a statistical analysis where you try different modeling approaches. You might start with a simple linear regression, commit those changes, then add a multiple regression analysis in another commit. If the more complex model doesn’t improve your results, you can easily revert to your earlier version. Each commit serves as a checkpoint in your analytical process, documenting your decision-making journey.

These basics will help you maintain organized, reproducible statistical analyses. As you become comfortable with these concepts, you can explore more advanced Git features like branching, collaboration, and remote repositories.