pizofreude/R_RStudioCloud_RStudioDesktop.md

Last active August 9, 2025 16:01

Star (0) You must be signed in to star a gist
Fork (0) You must be signed in to fork a gist

Select an option

Learn more about clone URLs
Clone this repository at <script src="https://gist.github.com/pizofreude/b31ff4ca8dff94c8bad2b14114820426.js"></script>
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)

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

D. Use RStudio Projects for Best Practice

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

File → New Project → Existing Directory
Select your folder (e.g., C:/workspace/My_Projects/alarm-projects)
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

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

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.
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().
After confirming your code works as expected, use renv::snapshot() to record the current package versions in the renv.lock file.
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:

Open RStudio.
Open your project using the .Rproj file (File > Open Project or double-click the .Rproj file).
Pull the latest changes from GitHub (git pull), if collaborating.
renv will automatically use your project’s local library. You don’t need to re-run renv::init() or manually activate anything.
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:

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

Every other time:

Open .Rproj file.
git pull (get updates).
renv::restore() (if needed).
Work as usual.
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

Step-by-Step Summary

Clone your repo from GitHub.
Open as an RStudio Project (create .Rproj if missing).
First time?
- Run renv::init() to start package management.
- Install needed packages, then renv::snapshot() to save renv.lock.
Returning to work:
- git pull to get latest code.
- If renv.lock changed, run renv::restore() to sync your environment.
Work on your scripts, notebooks, data, etc.
Save, commit, and push your changes to GitHub.
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.

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.

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):

In your R console within the project:

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

Check that renv.lock is updated (git status).
Commit and push the changes.
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

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:

Close RStudio.
Move the entire da-with-r folder from C:\Users\AbdulHafeez to C:\workspace.
Double-click da-with-r.Rproj in C:\workspace\da-with-r to reopen the project.
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.

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

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:

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

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"
)

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.

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:

Redshift connectivity for ELT pipeline integration
Rapid visualization prototyping with ggplot2 ecosystem
Professional presentation capabilities with Quarto
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.

pizofreude/R_RStudioCloud_RStudioDesktop.md

Select an option

No results found

Select an option

No results found

📚 R & RStudio: Working Directory Cheatsheet

1️⃣ RStudio Desktop: Setting the Working Directory

A. Launch from Terminal with Correct Directory

B. Change Directory Inside RStudio

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

D. Use RStudio Projects for Best Practice

2️⃣ RStudio Cloud: Working Directory Tips

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

4️⃣ Common Troubleshooting

5️⃣ Reference

pizofreude commented Jun 27, 2025 •

edited

Loading

Uh oh!

pizofreude commented Jun 27, 2025 •

edited

Loading

Uh oh!

pizofreude commented Jun 27, 2025 •

edited

Loading

Uh oh!

pizofreude commented Jun 27, 2025

Uh oh!

pizofreude commented Jun 29, 2025 •

edited

Loading

Uh oh!

pizofreude commented Jul 9, 2025 •

edited

Loading

Uh oh!

pizofreude commented Jul 11, 2025 •

edited

Loading

Uh oh!

pizofreude commented Jul 11, 2025 •

edited

Loading

Uh oh!

pizofreude/R_RStudioCloud_RStudioDesktop.md

📚 R & RStudio: Working Directory Cheatsheet

1️⃣ RStudio Desktop: Setting the Working Directory

A. Launch from Terminal with Correct Directory

B. Change Directory Inside RStudio

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

D. Use RStudio Projects for Best Practice

2️⃣ RStudio Cloud: Working Directory Tips

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

4️⃣ Common Troubleshooting

5️⃣ Reference

pizofreude commented Jun 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Workflow with RStudio Desktop and RStudio Cloud

1. Should I Create a New RStudio Project?

2. Using renv in Your Project

3. Daily Workflow

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

b) Ending Your Session

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

5. Summary Workflow

Example Terminal Session

R Project Visual Workflow with RStudio, renv, and GitHub

Step-by-Step Summary

Uh oh!

pizofreude commented Jun 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Global Installion of packages in R: single or bundle

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

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

Uh oh!

pizofreude commented Jun 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Project-based Package Installation in R: single or bundle

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

The Issue:

How to Fix It

1. Always Install Packages Into the renv Project Library

Preferred Approach:

Bulk Install From requirements.txt:

2. Rerun renv::snapshot()

3. Commit renv.lock and renv/ to GitHub

4. Best Practices: Making GitHub the Source of Truth

What to Do Now (Step by Step):

Summary Table

Uh oh!

pizofreude commented Jun 27, 2025

Setting Unrestricted Working Directory for RStudio Desktop

1. Set Default Working Directory in RStudio

2. For Command-Line git

3. Optional: Make a Shortcut for Quick Navigation

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

5. Move Existing Project

Uh oh!

pizofreude commented Jun 29, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Important RStudio Hotkeys

Summary

Uh oh!

pizofreude commented Jul 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

VS Code Settings for R

Quick R Test Run in VS Code

Uh oh!

pizofreude commented Jul 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

R Packages for Data Analytics & Engineering

High-Quality Package Selection

Additional Essential R Packages to Consider

Packages for Machine Learning

Presentation Tools

Uh oh!

pizofreude commented Jul 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Example Usage of R Packages for Data Analytics & Engineering

Key Highlights:

Core Advantages:

What I Excluded and Why:

Project-Specific Inclusions:

Installation Strategy:

pizofreude commented Jun 27, 2025 •

edited

Loading

pizofreude commented Jun 27, 2025 •

edited

Loading

pizofreude commented Jun 27, 2025 •

edited

Loading

pizofreude commented Jun 29, 2025 •

edited

Loading

pizofreude commented Jul 9, 2025 •

edited

Loading

pizofreude commented Jul 11, 2025 •

edited

Loading

pizofreude commented Jul 11, 2025 •

edited

Loading