Skip to content

Instantly share code, notes, and snippets.

@pizofreude

pizofreude/R_RStudioCloud_RStudioDesktop.md

Last active August 9, 2025 16:01
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save pizofreude/b31ff4ca8dff94c8bad2b14114820426 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save pizofreude/b31ff4ca8dff94c8bad2b14114820426 to your computer and use it in GitHub Desktop.
Download ZIP
Cheatsheet for R, RStudio Cloud, RStudio Desktop
Raw
R_RStudioCloud_RStudioDesktop.md

📚 R & RStudio: Working Directory Cheatsheet

This cheatsheet covers how to control and troubleshoot the working directory in R, RStudio Desktop, and RStudio Cloud. A correct working directory makes data import, script sourcing, and project management much smoother.

1️⃣ RStudio Desktop: Setting the Working Directory

A. Launch from Terminal with Correct Directory

Instead of just:

rstudio .

Use:

rstudio --cwd /path/to/your/directory

Example:

rstudio --cwd /c/workspace/My_Projects/alarm-projects

This ensures RStudio starts in the specified directory.

Update: better to use Rproj since we uses relative dir instead of specific path.

B. Change Directory Inside RStudio

  • Menu: Session → Set Working Directory → Choose Directory...
  • Shortcut: Ctrl + Shift + H
  • R Console Command: 
    setwd("C:/workspace/My_Projects/alarm-projects")

C. Set a Default Working Directory (for all new sessions)

  1. Go to Tools → Global Options → General
  2. Under Default working directory, set your path (e.g., C:/workspace/My_Projects/alarm-projects)
  3. Click Apply and restart RStudio

D. Use RStudio Projects for Best Practice

RStudio Projects automatically set the working directory to the project folder.

  1. File → New Project → Existing Directory
  2. Select your folder (e.g., C:/workspace/My_Projects/alarm-projects)
  3. RStudio creates a .Rproj file—always open this file to launch the project with the right directory!

2️⃣ RStudio Cloud: Working Directory Tips

  • RStudio Cloud always starts in the project’s root directory.
  • For reproducibility, always use RStudio Projects in the cloud too.
  • To check your current directory: 
    getwd()
  • To change it: 
    setwd("/cloud/project/subfolder")
  • Upload files to /cloud/project for easy access.

3️⃣ R Console (Base R): Set or Check Working Directory

  • Check current directory: 
    getwd()
  • Set working directory: 
    setwd("/path/to/your/directory")

4️⃣ Common Troubleshooting

  • Paths on Windows: use either / or double backslashes \\ (never single \).
  • Always check your current directory with getwd() if file loading fails.
  • Use Projects whenever possible—they save a ton of headaches!

5️⃣ Reference

Pro Tip:
Always use RStudio Projects for each analysis or codebase. They save window layouts, history, and—most importantly—set your working directory automatically!

Last updated: 2025-06-26

@pizofreude
Copy link
Author

pizofreude commented Jun 26, 2025

📚 R & RStudio Cheatsheet for Data Analysts & Data Engineers

A compact reference for R, RStudio Desktop, and RStudio Cloud—including working directory, data wrangling, visualization, and key workflows for analytics and engineering.

1️⃣ RStudio & R: Working Directory

  • Launch in specific directory (Terminal): 
    rstudio --cwd /path/to/dir
  • Change inside RStudio:
    Menu: Session → Set Working Directory → Choose Directory...
    Shortcut: Ctrl+Shift+H
  • R Console: 
    getwd()                # Check current
setwd("/path/to/dir")  # Set directory
  • Always use Projects!
    File → New Project → Existing Directory
  • Reference: RStudio Working Directories Guide

2️⃣ Data Import & Export

  • CSV: 
    df <- read.csv("file.csv")
write.csv(df, "output.csv", row.names=FALSE)
  • Excel: 
    library(readxl)
df <- read_excel("file.xlsx", sheet = 1)
  • Parquet/Arrow: 
    library(arrow)
df <- read_parquet("file.parquet")
write_parquet(df, "out.parquet")
  • Database (DBI + odbc): 
    library(DBI)
con <- dbConnect(odbc::odbc(), "DSN_Name")
df <- dbGetQuery(con, "SELECT * FROM table")
dbDisconnect(con)

3️⃣ Data Wrangling (dplyr & tidyr)

  • Select columns:
    df %>% select(col1, col2)
  • Filter rows:
    df %>% filter(col1 == "value")
  • Mutate/add columns:
    df %>% mutate(new_col = col1 * 2)
  • Summarise:
    df %>% summarise(mean_col = mean(col1, na.rm=TRUE))
  • Group by:
    df %>% group_by(col2) %>% summarise(count = n())
  • Join tables:
    left_join(df1, df2, by = "id")
  • Pivot wider/longer:
    pivot_longer(df, cols = c(colA, colB), names_to = "key", values_to = "value")

4️⃣ Data Cleaning

  • Remove NAs:
    df <- na.omit(df)
  • Replace values:
    df$col[df$col == "old"] <- "new"
  • Convert types:
    as.numeric(), as.character(), as.Date()
  • String ops:
    library(stringr)
    str_detect(df$col, "pattern")
    str_replace(df$col, "old", "new")

5️⃣ Data Visualization (ggplot2)

library(ggplot2)
ggplot(df, aes(x=col1, y=col2)) + 
    geom_point() +
    theme_minimal()
# Other types:
geom_bar(), geom_histogram(), geom_boxplot(), geom_line()

6️⃣ Programming (Base R)

  • Functions: 
    myfun <- function(x, y = 1) {
  return(x + y)
}
myfun(2, 3)
  • Apply family:
    apply(mat, 1, sum)
    lapply(list, mean)
  • Loops: 
    for (i in 1:10) { print(i) }

7️⃣ Data Table (High Performance)

library(data.table)
dt <- as.data.table(df)
dt[, .(mean_val = mean(col1)), by = col2]
dt[col1 > 10, .N]

8️⃣ RStudio Cloud Tips

  • Always use Projects—each Cloud project is isolated.
  • Upload data to /cloud/project
  • Use getwd(), setwd()
  • Install packages with install.packages("pkg")

9️⃣ Exporting Results

  • To CSV/Excel:
    write.csv(df, "mydata.csv")
    writexl::write_xlsx(df, "mydata.xlsx")
  • To Database:
    dbWriteTable(con, "tablename", df)

🔟 Reproducibility Best Practices

  • Use RStudio Projects for each analysis
  • Always set seed for random operations: set.seed(123)
  • Document your workflow in an R Markdown file (.Rmd)
  • Save session info: sessionInfo()

Useful Links

Last updated: 2025-06-26

@pizofreude
Copy link
Author

pizofreude commented Jun 27, 2025

R Environment (renv)

Here’s how renv works for R projects, especially if you’re coming from a Python/virtualenv background:

How renv Works (Compared to Python Virtual Environments)

  • renv is the R package for project-local package management, very similar to Python’s virtualenv or venv.
  • renv creates a local environment (library) of packages just for your R project.
  • Each R project should have its own renv environment.
    (Just like in Python, each project should have its own virtual environment.)

The Workflow

  1. Initialize renv in your project:
    When you run renv::init() in your repo, it creates a local environment (in the renv/ directory) and a renv.lock file.
  2. Install packages as usual:
    Install packages with install.packages() or renv::install(), and they’ll be installed in your project’s local library, not the global/system R library.
  3. Share your environment:
    • When you commit renv.lock and your project files to GitHub, anyone can clone your repo and run renv::restore() to get the exact same package versions.
    • This is like committing a requirements.txt or Pipfile.lock in Python.
  4. No need to manually create system-wide R environments:
    • Each project (repo) that uses renv is isolated from others, so you don’t have to worry about package version conflicts.

Key Points

  • You should initialize renv for each new R project/repo.
  • renv is project-specific, not user- or system-wide.
  • If you start a new project, run renv::init() in that new project’s directory.
  • When you switch projects (repos), renv automatically uses the right local library for each.

In Summary

  • Yes: You still create a virtual environment for each new R project, but renv makes this easy and automatic.
  • No: You do not create just one renv environment for all your R projects. Each project gets its own (just like Python best practice).

Example in Your Repo

# Initialize renv in your project (run this once)
renv::init()

# Install packages (within the project)
install.packages("dplyr")
install.packages("ggplot2")

# Snapshot the environment (save package versions)
renv::snapshot()

# When someone else (or you on another system) clones the repo:
renv::restore()

@pizofreude
Copy link
Author

pizofreude commented Jun 27, 2025 •
edited
Loading

Workflow with RStudio Desktop and RStudio Cloud

Here’s a step-by-step workflow for using renv and RStudio Projects, with guidance for both new and returning sessions:

1. Should I Create a New RStudio Project?

Yes, you should!
For every analytical project (especially when using renv), it’s best to create an RStudio Project (.Rproj file) in your repo folder.

  • This keeps your working directory, settings, and project environment isolated.
  • RStudio Projects work seamlessly with renv and Git.

How to create:

  • In RStudio Desktop:
    • File > New Project > Existing Directory > Choose your cloned repo folder.
    • This creates a .Rproj file in your directory.
  • In RStudio Cloud:
    • Create a new project from your GitHub repo; RStudio Cloud will automatically set up the project.

2. Using renv in Your Project

Installation

To install the latest version of renv, run these in R console (not terminal):

install.packages("renv")

Alternatively, you can install the development version from r-universe:

install.packages("renv", repos = "https://r-universe.dev")

Workflow

  1. Initialize renv in a new or existing project using renv::init() via R console and not the terminal. This will set up a project library and create a renv.lock file to record the packages and their versions.

  2. As you work on the project, install and upgrade packages using either install.packages() and update.packages() or the renv-specific functions renv::install() and renv::update().

  3. After confirming your code works as expected, use renv::snapshot() to record the current package versions in the renv.lock file.

  4. When sharing your code or running it on a new machine, your collaborator (or you) can use renv::restore() to reinstall the specific package versions recorded in the renv.lock file, ensuring a reproducible environment.

  • After opening your project (with .Rproj), run renv::init() if you haven't already done so.
  • Install your packages as needed; renv will manage them for this project only.
  • When you install new packages, run renv::snapshot() to update renv.lock.

3. Daily Workflow

a) Starting a New Session (Next Day or Later)

In RStudio Desktop:

  1. Open RStudio.
  2. Open your project using the .Rproj file (File > Open Project or double-click the .Rproj file).
  3. Pull the latest changes from GitHub (git pull), if collaborating.
  4. renv will automatically use your project’s local library. You don’t need to re-run renv::init() or manually activate anything.
  5. If you or a collaborator have changed the renv.lock file, run renv::restore() to ensure your packages match.

In RStudio Cloud:

  • Open your project workspace as before.
  • Pull latest changes, and run renv::restore() if the renv.lock file was updated.

b) Ending Your Session

  • Save all your scripts/notebooks.
  • Commit and push your changes to GitHub (git add, git commit, git push) if using Git.
  • Close RStudio or the Cloud workspace.

4. Do You Need to Create a New .Rprofile File?

  • No, you do not need to manually create a .Rprofile file for basic use. renv and RStudio Projects handle environment setup for you.
  • If you want custom startup commands, you can edit .Rprofile, but it’s not required for renv/project workflow.

5. Summary Workflow

First time:

  1. Clone repo.
  2. Create/open RStudio Project in that folder.
  3. renv::init() (if not already done).
  4. Install packages.
  5. renv::snapshot()
  6. Commit everything (.Rproj, renv.lock, scripts) to GitHub.

Every other time:

  1. Open .Rproj file.
  2. git pull (get updates).
  3. renv::restore() (if needed).
  4. Work as usual.
  5. Save, commit, push changes.

Example Terminal Session

cd \path\to\workingDir
rstudio da-with-r.Rproj    # or open in RStudio GUI
# In RStudio console:
git pull
renv::restore()            # If you see renv.lock updated
# ...do your work...
renv::snapshot()           # If you added/removed packages
git add .
git commit -m "Update analysis and packages"
git push

R Project Visual Workflow with RStudio, renv, and GitHub

R-workflow

Step-by-Step Summary

  1. Clone your repo from GitHub.
  2. Open as an RStudio Project (create .Rproj if missing).
  3. First time?
    • Run renv::init() to start package management.
    • Install needed packages, then renv::snapshot() to save renv.lock.
  4. Returning to work:
    • git pull to get latest code.
    • If renv.lock changed, run renv::restore() to sync your environment.
  5. Work on your scripts, notebooks, data, etc.
  6. Save, commit, and push your changes to GitHub.
  7. Repeat steps 4-6 for every new session.
  • Always open your project via the .Rproj file.
  • Use renv to manage packages locally, per project.
  • Use Git/GitHub to sync code and environment files.
  • Restore your renv on every new environment or after renv.lock changes.

@pizofreude
Copy link
Author

pizofreude commented Jun 27, 2025 •
edited
Loading

Global Installion of packages in R: single or bundle

In Python, it's common to install project libraries in bundle via:

pip install -r requirements.txt

But, in R install.packages() is meant for installing individual R packages, not for handling a requirements.txt file—that format is actually from the Python ecosystem. So when R sees 'requirements.txt', it assumes it's the name of an R package and tries (unsuccessfully) to find and install it.

Here’s how you can handle package installation in R correctly:

✅ If You're Trying to Install R Packages from a List

If your requirements.txt contains a list of R packages (one per line), you can read the file and install them like this:

packages <- readLines("requirements.txt")
install.packages(packages)

🧩 If It’s Actually a Python Requirements File (for Reticulate or Similar)

If you're using [reticulate](https://rstudio.github.io/reticulate/) to integrate Python into your R environment and need to install Python dependencies:

reticulate::py_install(packages = NULL, requirements = "requirements.txt")

Make sure your Python environment (e.g. conda or virtualenv) is active or correctly initialized before this step.

@pizofreude
Copy link
Author

pizofreude commented Jun 27, 2025 •
edited
Loading

Project-based Package Installation in R: single or bundle

Using install.packages() will globally install the packages and not project specific! Here’s a clear explanation of what’s happening and how to ensure your renv setup and GitHub repository are truly the “Source of Truth” for your R project environment.

Why is renv::snapshot() not updating the lockfile?

The Issue:

  • You installed packages with install.packages(), which by default installs them to your global R library, not your renv project library.
  • renv::snapshot() only records packages in your project-local renv library, not the global one.
  • That’s why your renv.lock isn’t being updated—even if you installed new packages.

How to Fix It

1. Always Install Packages Into the renv Project Library

Preferred Approach:

  • Use renv::install("package_name") for each package.
    Example: 
    renv::install("dplyr")
renv::install("ggplot2")
  • This ensures the package is installed in renv’s private library for your project.

Bulk Install From requirements.txt:

If you want to install from a list (like requirements.txt), do:

packages <- readLines("requirements.txt")
renv::install(packages)

2. Rerun renv::snapshot()

  • After installing with renv, run: 
    renv::snapshot()    #single
renv::snapshot(type = "all")    #bundle
  • Now, renv.lock will reflect the actual state of your project library, and you’ll see changes to commit.

3. Commit renv.lock and renv/ to GitHub

  • Add and commit renv.lock (and the .Rproj file, if new/changed): 
    git add renv.lock da-with-r.Rproj
git commit -m "Update project environment and lockfile"
git push
  • Do not commit renv/library/ (it’s usually in .gitignore by default).

4. Best Practices: Making GitHub the Source of Truth

  • Only ever install packages via renv::install() (or tools like devtools::install_github() inside your project context).
  • Never use install.packages() for project dependencies unless you’re inside an active renv project and want to install locally—renv::install() is always safest.
  • renv.lock is the definitive record of your project’s package environment. Anyone (including you) can clone the repo and run renv::restore() to get the exact same package versions.

What to Do Now (Step by Step):

  1. In your R console within the project: 
    packages <- readLines("requirements.txt")
renv::install(packages)
renv::snapshot()
  2. Check that renv.lock is updated (git status).
  3. Commit and push the changes.
  4. Going forward, always use renv::install() for new packages.

Summary Table

Task Correct Command Where It Goes
Install Packages renv::install("pkg") renv local library
Bulk Install renv::install(readLines("requirements.txt")) renv local library
Record Environment renv::snapshot() #single / renv::snapshot(type = "all") #bundle updates renv.lock
Reproduce on New Machine renv::restore() from renv.lock
Commit to GitHub git add renv.lock .Rproj version control

@pizofreude
Copy link
Author

pizofreude commented Jun 27, 2025

Setting Unrestricted Working Directory for RStudio Desktop

Yes, Windows protects your user folder (C:\Users\...) with special permissions, which can cause issues for R, RStudio, renv, and sometimes git.

Cloning your repos to a simpler location like C:\workspace is a great idea.

Here’s how to set that up as your default location for cloning via RStudio (and some tips for git in general):

1. Set Default Working Directory in RStudio

RStudio does not have a global “default repo location” for cloning, but you can specify the folder every time you clone:

  • In RStudio:
    • Go to File > New Project...
    • Choose Version Control > Git
    • For Repository URL, enter your GitHub repo URL.
    • For Project Directory Name, enter your desired folder name (e.g., da-with-r).
    • For Create project as a subdirectory of:, click Browse... and choose C:\workspace as the location.
    • Click Create Project.

From now on, just always select C:\workspace when cloning new projects in RStudio.

2. For Command-Line git

If you use git bash or command prompt for cloning, just:

cd C:\workspace
git clone <repo-url>

3. Optional: Make a Shortcut for Quick Navigation

  • Create a shortcut to C:\workspace on your Desktop for easy access.

4. (Advanced) Change Default Folder for New RStudio Projects

You can also set the default working directory for new projects in RStudio:

  • Go to Tools > Global Options > General
  • Under Default working directory (when not in a project): set it to C:/workspace
  • This won’t affect the clone dialog directly, but will put you in the right place for new projects/files.

5. Move Existing Project

If you want to move your current project:

  1. Close RStudio.
  2. Move the entire da-with-r folder from C:\Users\AbdulHafeez to C:\workspace.
  3. Double-click da-with-r.Rproj in C:\workspace\da-with-r to reopen the project.
  4. Test renv::activate() and everything should still work.

Summary:
Whenever you clone a repo in RStudio, just pick C:\workspace as the location. No need to set a global default—just always choose this path in the dialog.

@pizofreude
Copy link
Author

pizofreude commented Jun 29, 2025 •
edited
Loading

Important RStudio Hotkeys

Here are the most important RStudio keyboard shortcuts. These work on Windows, macOS, and Linux; We’ll show both variants where relevant.

Script & Console Editing

  • Comment/Uncomment:
    • Windows/Linux: Ctrl + Shift + C
    • Mac: Command + Shift + C
  • Run Current Line/Selection:
    • Windows/Linux: Ctrl + Enter
    • Mac: Command + Enter
  • Run All:
    • Windows/Linux: Ctrl + Alt + R
    • Mac: Command + Option + R
  • Run Selected Lines and Move Cursor Down:
    • Windows/Linux: Alt + Enter
    • Mac: Option + Enter
  • Insert Section:
    • Windows/Linux: Ctrl + Shift + R
    • Mac: Command + Shift + R
  • Reindent Selected Lines:
    • Windows/Linux: Ctrl + I
    • Mac: Command + I

Navigation

  • Go to File/Function:
    • Windows/Linux: Ctrl + .
    • Mac: Command + .
  • Jump to Console:
    • Windows/Linux: Ctrl + 2
    • Mac: Command + 2
  • Jump to Source Editor:
    • Windows/Linux: Ctrl + 1
    • Mac: Command + 1
  • Show Keyboard Shortcuts Help:
    • Windows/Linux: Alt + Shift + K
    • Mac: Option + Shift + K

Miscellaneous

  • Insert Pipe (%>%) Operator: P/S: |> is the new pipe
    • Windows/Linux: Ctrl + Shift + M
    • Mac: Command + Shift + M
  • Find in File:
    • Windows/Linux: Ctrl + F
    • Mac: Command + F
  • Replace in File:
    • Windows/Linux: Ctrl + H
    • Mac: Command + Option + F

Session Control

  • Restart R Session:
    • Windows/Linux: Ctrl + Shift + F10
    • Mac: Command + Shift + F10
  • Interrupt R:
    • Windows/Linux: Esc
    • Mac: Esc

File Management

  • New Script:
    • Windows/Linux: Ctrl + Shift + N
    • Mac: Command + Shift + N
  • Save Script:
    • Windows/Linux: Ctrl + S
    • Mac: Command + S

These are the essentials for productivity in RStudio.

Summary

Action Windows/Linux Shortcut macOS Shortcut
Comment/Uncomment Ctrl + Shift + C Command + Shift + C
Run Current Line/Selection Ctrl + Enter Command + Enter
Run All Ctrl + Alt + R Command + Option + R
Run Selected Lines & Move Down Alt + Enter Option + Enter
Insert Section Ctrl + Shift + R Command + Shift + R
Reindent Selected Lines Ctrl + I Command + I
Go to File/Function Ctrl + . Command + .
Jump to Console Ctrl + 2 Command + 2
Jump to Source Editor Ctrl + 1 Command + 1
Show Keyboard Shortcuts Help Alt + Shift + K Option + Shift + K
Insert Pipe (%>%) Operator Ctrl + Shift + M Command + Shift + M
Find in File Ctrl + F Command + F
Replace in File Ctrl + H Command + Option + F
Restart R Session Ctrl + Shift + F10 Command + Shift + F10
Interrupt R Esc Esc
New Script Ctrl + Shift + N Command + Shift + N
Save Script Ctrl + S Command + S

@pizofreude
Copy link
Author

pizofreude commented Jul 9, 2025 •
edited
Loading

VS Code Settings for R

To implement the specified R terminal options in VS Code settings, follow these steps:

  1. Open VS Code settings: Press Ctrl + Shift + P (Windows/Linux) or Cmd + Shift + P (Mac) to open the Command Palette. Type "Open User Settings (JSON)" and select the option.
  2. Add R terminal options: In the settings.json file, add the following code:
{
    "r.rterm.option": [
        "--r-binary=/c/Program Files/R/R-4.5.1/bin/R", // Replace with your R path as set PATH
        "--no-save", // Optional: Prevent saving the workspace at the end of the session
        "--no-restore", // Optional: Prevent restoring workspaces
    ],
    "r.rterm.windows": "C:\\Program Files\\R\\R-4.5.1\\bin\\R.exe", // Replace with your R path
    "r.rterm.linux": "/usr/bin/R", // Replace with your R path on Linux
    "r.rterm.mac": "/usr/local/bin/R" // Replace with your R path on macOS
}
  1. Save the settings: Save the settings.json file to apply the changes.

Note: Make sure to replace "/c/Program Files/R/R-4.5.1/bin/R" with the actual path to your R executable as set in your system's PATH environment variable.

By adding these options, you can control the behavior of the R terminal in VS Code, such as preventing workspace saving and restoring.

Quick R Test Run in VS Code

# File: demo.R
example <- 123

example_data <- data.frame(
    ID = 1:10,
    Age = sample(18:50, 10, replace = TRUE),
    Score = round(runif(10, 50, 100), 1)
)

print(example_data)

hist(example_data$Age,
    main = "Histogram of Ages",
    xlab = "Age",
    ylab = "Frequency",
    col = "lightblue", 
    border = "black"
)

@pizofreude
Copy link
Author

pizofreude commented Jul 11, 2025 •
edited
Loading

R Packages for Data Analytics & Engineering

This list of R packages is an excellent starting point for a professional data analyst. It covers a wide range of essential tasks, from data manipulation and visualization to reporting and project management. Here's a detailed breakdown of the list and some additional recommendations.

High-Quality Package Selection

The packages listed are widely recognized and frequently used in the data analysis community. Here's a look at their primary functions:

Core Data Science Workflow:

  • tidyverse: This is a powerful collection of R packages designed for data science that share an underlying design philosophy, grammar, and data structures. It's an essential installation, and it's worth noting that it already includes several of the other packages on the list: ggplot2, dplyr, readr, stringr, forcats, and tibble.
  • lubridate: This package simplifies working with dates and times, a common and often tricky task in data analysis.
  • janitor: Excellent for cleaning and examining data, with functions for tidying up column names and finding duplicate records.
  • skimr: Provides a quick and comprehensive overview of your dataset, offering more detailed summary statistics than the base R summary() function.

Data Manipulation and Visualization:

  • dplyr: A core component of the tidyverse, it provides a consistent set of verbs to solve the most common data manipulation challenges.
  • ggplot2: The go-to package for creating a wide variety of static and interactive data visualizations in R.
  • readr: Part of the tidyverse, it provides a fast and friendly way to read rectangular data like CSV files.
  • stringr: This tidyverse package offers a cohesive set of functions for working with strings, which is crucial for handling text data.
  • forcats: A tidyverse package that provides tools for working with categorical variables (factors).
  • tibble: A modern take on data frames, also part of the tidyverse. They offer a more user-friendly printing method and are stricter in their behavior, which helps to catch errors earlier.

Reporting and Project Management:

  • knitr and rmarkdown: These packages are fundamental for creating dynamic and reproducible reports, presentations, and dashboards that combine code, output, and narrative text.
  • testthat: A package for unit testing your code. While not directly for data analysis, it's a critical tool for ensuring the quality and reliability of your work, especially in professional settings.
  • arrow: This package is particularly useful for working with large datasets, enabling efficient data reading and writing.
  • here: Simplifies the process of managing file paths in your projects, making your work more portable and reproducible.
  • packrat: A tool for managing project-specific package dependencies, ensuring that your projects are isolated and reproducible. However, it is worth noting that renv is now the recommended successor.

Specialized Analysis:

  • SimDesign: A package designed for conducting Monte Carlo simulations. While powerful, its necessity depends on the specific requirements of your data analysis role.

Additional Essential R Packages to Consider

The above list is very thorough, but here are a few more packages that are highly recommended for a professional data analyst:

  • tidyr: This is a core member of the tidyverse. It provides functions to help you create "tidy" data, where each variable is a column, each observation is a row, and each type of observational unit is a table. It's indispensable for data cleaning and reshaping.
  • data.table: An alternative to dplyr for data manipulation. It is renowned for its high performance and memory efficiency, making it a great choice for working with very large datasets.
  • shiny: If you need to create interactive web applications and dashboards directly from your R code, shiny is the go-to package.
  • quarto: A next-generation open-source scientific and technical publishing system from Posit (formerly RStudio). It can be considered a successor to R Markdown and offers broader language support and more features.
  • renv: As mentioned, renv is the modern successor to packrat for project dependency management. It is now the recommended tool for creating reproducible R environments.

Packages for Machine Learning

If your role as a data analyst extends to predictive modeling and machine learning, you should also consider:

  • tidymodels: A collection of packages for modeling and machine learning that follows the principles of the tidyverse. It provides a consistent and flexible framework for the entire modeling process.
  • caret: An older but still very popular package that provides a unified interface to a vast number of machine learning algorithms.
  • mlr3: Another powerful and extensible framework for machine learning in R.

Presentation Tools

Use modern, professional business slides in R, Quarto + reveal.js which is arguably the best overall.

@pizofreude
Copy link
Author

pizofreude commented Jul 11, 2025 •
edited
Loading

Example Usage of R Packages for Data Analytics & Engineering

Based on our specific use cases for the Divvy bike data engineering project, here's a curated list of R packages optimized for our needs: I've created a curated list of 16 essential R packages specifically tailored for our Divvy data engineering project. Here's why this selection is optimized for our needs:

Key Highlights:

Core Advantages:

  • Minimal Package Count: Only 16 packages vs. the 15+ mentioned in the full listings, avoiding bloat
  • Project-Specific: Focused on bike share data analysis, revenue calculations, and Redshift connectivity
  • Professional Presentation: Quarto + reveal.js for modern business slides
  • ELT Integration: Database connectivity packages for our Redshift-based architecture

What I Excluded and Why:

  • arrow - We're using Redshift, not direct Parquet manipulation
  • data.table - Tidyverse is sufficient for our analysis scale
  • shiny - We're using Tableau Public for final dashboards
  • testthat - dbt handles our data testing needs
  • Machine Learning packages - Not required for our business analysis focus

Project-Specific Inclusions:

  • DBI, RPostgres, dbplyr - Essential for connecting R to our Redshift data warehouse
  • scales - Perfect for formatting revenue calculations ($0.19/minute, percentages)
  • plotly - Interactive exploration of station utilization patterns
  • lubridate - Critical for analyzing trip timestamps and duration calculations

Installation Strategy:

The artifact provides a phased installation approach so we can install packages as needed, plus the complete renv workflow for reproducible environments.

Essential R Packages for Divvy Data Engineering Project

Core Installation Command for renv

# Initialize renv environment
renv::init()

# Install essential packages
renv::install(c(
  # Core tidyverse (includes ggplot2, dplyr, readr, stringr, forcats, tibble)
  "tidyverse",
  "tidyr",
  
  # Data manipulation and analysis
  "lubridate",
  "janitor",
  "skimr",
  
  # Database connectivity (for Redshift)
  "DBI",
  "RPostgres",
  "dbplyr",
  
  # Visualization and rapid prototyping
  "plotly",
  "scales",
  "viridis",
  "patchwork",
  
  # Presentation and reporting
  "quarto",
  "knitr",
  "rmarkdown",
  
  # Project management
  "here",
  "renv"
))

# Snapshot the environment
renv::snapshot()

Package Categories and Justifications

1. Core Data Science Workflow (Essential)

  • tidyverse - Comprehensive suite including ggplot2, dplyr, readr, stringr, forcats, tibble
  • tidyr - Data reshaping and cleaning (not automatically included in tidyverse)
  • lubridate - Date/time manipulation (crucial for bike trip timestamps)
  • janitor - Data cleaning and column name standardization
  • skimr - Quick dataset overviews and summary statistics

2. Database Connectivity (Project-Specific)

  • DBI - Database interface foundation
  • RPostgres - PostgreSQL/Redshift connectivity
  • dbplyr - dplyr syntax for database queries (essential for Redshift integration)

3. Visualization and Rapid Prototyping (Core Need)

  • plotly - Interactive visualizations for exploration
  • scales - Scale functions for ggplot2 (revenue formatting, percentages)
  • viridis - Color scales that are colorblind-friendly
  • patchwork - Combining multiple ggplot2 plots

4. Presentation Tools (Your Preference)

  • quarto - Modern publishing system with reveal.js integration
  • knitr - Code chunk processing (required by quarto)
  • rmarkdown - Markdown processing (quarto dependency)

5. Project Management (Professional Standards)

  • here - Robust file path management
  • renv - Package dependency management (already chosen)

Packages NOT Recommended for Your Use Case

Skip These (Not Needed):

  • arrow - You're using Redshift, not Parquet files directly in R
  • data.table - tidyverse approach is sufficient for your analysis scale
  • testthat - dbt handles data testing; R code will be exploratory
  • SimDesign - Monte Carlo simulations not relevant to bike share analysis
  • shiny - Using Tableau Public for final dashboards
  • tidymodels/caret/mlr3 - No machine learning requirements mentioned
  • packrat - Superseded by renv

Installation Strategy

Phase 1: Core Setup

# Essential packages for immediate work
core_packages <- c("tidyverse", "tidyr", "lubridate", "janitor", "skimr", "here")
renv::install(core_packages)
# OR
install.packages(core_packages)

Phase 2: Database Integration

# Database connectivity for Redshift
db_packages <- c("DBI", "RPostgres", "dbplyr")
renv::install(db_packages)
# OR
install.packages(db_packages)

Phase 3: Visualization Enhancement

# Advanced visualization capabilities
viz_packages <- c("plotly", "scales", "viridis", "patchwork")
renv::install(viz_packages)
# OR
install.packages(viz_packages)

Phase 4: Presentation Tools

# Modern presentation system
presentation_packages <- c("quarto", "knitr", "rmarkdown")
renv::install(presentation_packages)
# OR
install.packages(presentation_packages)

Project-Specific Considerations

For Divvy Data Analysis:

  • lubridate - Essential for trip start/end time analysis
  • scales - Format revenue calculations (dollar signs, percentages)
  • dbplyr - Write dplyr code that translates to SQL for Redshift
  • plotly - Interactive exploration of station utilization patterns

For Business Presentations:

  • quarto + reveal.js - Professional slide presentations
  • viridis - Accessible color palettes for executive presentations
  • patchwork - Combine multiple revenue/usage charts

renv Workflow

# Initialize project
renv::init()

# Install packages as needed
renv::install("package_name")
# OR
install.packages("package_name")

# Snapshot current state
renv::snapshot()

# Share project (others can restore with)
renv::restore()

Total Package Count: 16 Essential Packages

This curated list focuses on your specific needs while avoiding bloat. The selection prioritizes:

  1. Redshift connectivity for ELT pipeline integration
  2. Rapid visualization prototyping with ggplot2 ecosystem
  3. Professional presentation capabilities with Quarto
  4. Business-focused analysis tools for revenue and operational metrics

This streamlined approach ensures fast installation, minimal dependency conflicts, and focused functionality for your Divvy bike data engineering project.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment