chore: sync content to repo (#10280)

Co-authored-by: nilbuild <4921183+nilbuild@users.noreply.github.com>

roadmaps/r-programming/content/aesthetic-mappings@HDWIMwjBFh4vKw_BYo0bF.md

@@ -0,0 +1,9 @@
+# Aesthetic Mappings
+
+Aesthetic mappings connect columns in your data to visual properties of a plot, like position, color, size, or shape. Writing `aes(x = year, y = revenue, color = region)` tells ggplot2 to plot year against revenue and color each point by region. Choosing the right aesthetics for the right variables makes the difference between a clear plot and a confusing one.
+
+Visit the following resources to learn more:
+
+- [@article@Construct aesthetic mappings](https://ggplot2.tidyverse.org/reference/aes.html)
+- [@article@Aesthetic Mappings](https://data-vis-using-r.info/10_aesthetics/aesthetics.html)
+- [@video@Data Visualization with R: Aesthetic Mappings](https://www.youtube.com/watch?v=Kz-NDwt1plU)

roadmaps/r-programming/content/apis@V_cnhs4qzp-SLnLaGXC1l.md

@@ -0,0 +1,9 @@
+# APIs
+
+Web APIs let you request data over the internet from another service, typically returning it in JSON format. Fetching data from an API in R usually means making an HTTP request with a package like httr, then parsing the response. This combination of requesting and parsing is essential for working with any modern data source that exposes an API rather than a static file.
+
+Visit the following resources to learn more:
+
+- [@article@R API Tutorial: Getting Started with APIs in R](https://www.dataquest.io/blog/r-api-tutorial/)
+- [@article@Web APIs in R](https://www.gastonsanchez.com/R-web-technologies/4-01-apis-intro.html)
+- [@video@Access & Collect Data with APIs in R](https://www.youtube.com/watch?v=7XDDI0BnDAw)

roadmaps/r-programming/content/apply-family@yqCapCzAFkWZvebvkuHNV.md

@@ -0,0 +1,9 @@
+# Apply Family
+
+The apply family is a set of base R functions that apply another function to every element of a vector, list, or data structure, replacing many uses of explicit loops. `lapply()` always returns a list, `sapply()` tries to simplify the result into a vector or matrix, and `vapply()` works like `sapply()` but requires specifying the expected output type in advance. These functions predate the tidyverse's purrr package, which offers similar functionality with more consistent behavior.
+
+Visit the following resources to learn more:
+
+- [@article@apply family in r apply(), lapply(), sapply(), mapply() and tapply()](https://www.r-bloggers.com/2021/05/apply-family-in-r-apply-lapply-sapply-mapply-and-tapply/)
+- [@article@apply, lapply, sapply in R: The apply Family Explained](https://coddy.tech/docs/r/apply-family)
+- [@video@Apply Functions in R](https://www.youtube.com/watch?v=i8xYAX5dH-o)

roadmaps/r-programming/content/arguments--defaults@qSJI_xsSN3wPY3ud0bZdm.md

@@ -0,0 +1,8 @@
+# Arguments & Defaults
+
+Function arguments are the inputs a function accepts, and default values let you specify what an argument should be if the caller doesn't provide one. Writing `function(x, na.rm = FALSE)` means `na.rm` defaults to `FALSE` unless the caller overrides it. R also supports `...` to let a function accept a variable number of additional arguments, often passed through to another function inside.
+
+Visit the following resources to learn more:
+
+- [@article@R Functions](https://adv-r.hadley.nz/functions.html)
+- [@video@Create functions in R](https://www.youtube.com/watch?v=dCyj1MCOMrw)

roadmaps/r-programming/content/arrays@fy2pI0rjkw9d8THIHgDuN.md

@@ -0,0 +1,8 @@
+# Arrays
+
+An array generalizes a matrix to more than two dimensions, storing values of a single type across any number of dimensions you specify. Arrays are less common in everyday data analysis than vectors or data frames, but they appear in specialized numerical and scientific computing contexts. R indexes into them using the same bracket notation used for vectors and matrices, just with an extra dimension for each additional axis.
+
+Visit the following resources to learn more:
+
+- [@article@R Arrays](https://www.w3schools.com/r/r_arrays.asp)
+- [@video@R Basics 11 - Arrays](https://www.youtube.com/watch?v=oYhP2WZYpBY)

roadmaps/r-programming/content/base-r-plotting@Ytwncvf4YOgLPNnczOpts.md

@@ -0,0 +1,9 @@
+# Base R Plotting
+
+Base R includes plotting functions like `plot()`, `hist()`, and `boxplot()` that don't require any additional package. They're quick to use for a fast look at data and require no setup. Base R plots are generally less polished and more manual to customize than ggplot2, since you build them up layer by layer using separate function calls.
+
+Visit the following resources to learn more:
+
+- [@article@Simple base R plots](https://intro2r.com/simple-base-r-plots.html)
+- [@article@R Plotting](https://www.w3schools.com/r/r_graph_plot.asp)
+- [@video@Introduction to R: Plotting in Base R](https://www.youtube.com/watch?v=8HD4riFaqYs)

roadmaps/r-programming/content/basic-syntax@nDFlbYOe7U7mVJadKYy_W.md

@@ -0,0 +1,10 @@
+# Basic Syntax
+
+Basic R syntax is the small set of building blocks used to write any R code: variables, operators, comments, and simple control structures. Getting comfortable with these is necessary before anything more complex makes sense.
+
+Visit the following resources to learn more:
+
+- [@book@R for Data Science (2e)](https://r4ds.hadley.nz/)
+- [@video@Harvard CS50’s Intro to R Programming](https://www.youtube.com/watch?v=g_3IKHG-rfA)
+- [@video@Learn R in 39 minutes](https://www.youtube.com/watch?v=yZ0bV2Afkjc)
+- [@video@R programming in one hour - a crash course for beginners](https://www.youtube.com/watch?v=eR-XRSKsuR4)

roadmaps/r-programming/content/best-practices@OLOZSNHrOFD3claBXNKxP.md

@@ -0,0 +1,9 @@
+# Best Practices
+
+Good data visualization practice means choosing chart types and design choices that communicate data accurately rather than misleadingly. Common anti-patterns include truncated axes that exaggerate differences and color choices that aren't accessible to colorblind viewers. A technically correct chart can still mislead its audience if these principles are ignored.
+
+Visit the following resources to learn more:
+
+- [@article@ggplot tips](https://www.epirhandbook.com/en/new_pages/ggplot_tips.html)
+- [@article@Simple Tricks to Improve ggplot Figures](https://medium.com/@sophiekearney/simple-tricks-to-improve-ggplot-figures-010202415824)
+- [@video@Good Data Visualizations Don't Take Much Time | A ggplot2 Tutorial](https://www.youtube.com/watch?v=U8CrTL2kIDA)

roadmaps/r-programming/content/big-data-tools@GkxSrpOJx-SWvnDkTPcJt.md

@@ -0,0 +1,9 @@
+# Big Data Tools
+
+Big data tools handle datasets too large or too slow to work with comfortably using standard R data manipulation. They include techniques for parallelizing computation and connecting to distributed processing systems.
+
+Visit the following resources to learn more:
+
+- [@article@What is big data?](https://www.okanbulut.com/bigdata/intro.html)
+- [@article@Super Saiyan Data Skills: Mastering Big Data with R](https://www.r-bloggers.com/2024/04/super-saiyan-data-skills-mastering-big-data-with-r/)
+- [@article@Efficient Techniques for Large Data Handling in R: A Comprehensive Guide](https://medium.com/@melsiddieg/efficient-techniques-for-large-data-handling-in-r-a-comprehensive-guide-8a3173cc6b1c)

roadmaps/r-programming/content/casting-types@XI8bvhQ3ugezTu60USUG2.md

@@ -0,0 +1,10 @@
+# Casting Types
+
+Casting converts a column to the correct type, such as turning character `"42"` into the numeric value `42`. Data often arrives in the wrong type for analysis, especially numbers or dates stored as plain text. Getting the types right early avoids confusing errors later when a function expects a number but receives text instead.
+
+Visit the following resources to learn more:
+
+- [@article@Changing Data Type of variables in R](https://thedatahall.com/changing-data-type-in-r/)
+- [@article@typecast: Atomic and List Type Casting With Names and Dimensions Preserved](https://www.rdocumentation.org/packages/broadcast/versions/0.1.8/topics/typecast)
+- [@video@Converting Data types in R || R programming tutorials](https://www.youtube.com/watch?v=jcHHmbWcngc)
+- [@video@Data types in R programming](https://www.youtube.com/watch?v=VtUVQWl0aRA)

roadmaps/r-programming/content/character@ghrVl-VfVDvpyBIl6N4xM.md

@@ -0,0 +1,8 @@
+# Character
+
+Character is R's type for text, written inside single or double quotes, like `"hello"`. R provides many built-in and package functions for searching, splitting, and reformatting text stored this way. Character data shows up constantly in real datasets: names, categories, free-text responses, file paths.
+
+Visit the following resources to learn more:
+
+- [@article@Character](https://www.r-tutor.com/r-introduction/basic-data-types/character)
+- [@article@R Strings](https://www.w3schools.com/r/r_strings.asp)

roadmaps/r-programming/content/comments@IahDxQfLvld-qCAeAuAo-.md

@@ -0,0 +1,8 @@
+# Comments
+
+Comments start with `#` and are ignored when R runs the code, letting you leave notes explaining what a piece of code does or why. They don't affect how a script executes, but they make code easier to understand later, whether for someone else or for yourself after time has passed. Good commenting habits pay off especially once scripts grow beyond a few lines.
+
+Visit the following resources to learn more:
+
+- [@article@R Comments](https://www.w3schools.com/r/r_comments.asp)
+- [@video@how to add comments in your R codes](https://www.youtube.com/watch?v=1ELURZg8IIY)

roadmaps/r-programming/content/common-plots@1uWW6PP2uWqKU4Ya5GzVO.md

@@ -0,0 +1,8 @@
+# Common Plots
+
+Common plot types include line plots for trends over time, bar plots for comparing quantities across categories, histograms for showing the distribution of a single numeric variable, and boxplots for summarizing spread and outliers. Each type suits a different kind of question about the data. Learning when to reach for which one is as important as knowing the syntax to produce it.
+
+Visit the following resources to learn more:
+
+- [@article@Top 50 ggplot2 Visualizations - The Master List (With Full R Code)](https://r-statistics.co/Top50-Ggplot2-Visualizations-MasterList-R-Code.html)
+- [@article@ggplot2 R Galery](https://r-graph-gallery.com/ggplot2-package.html)

roadmaps/r-programming/content/complex@SQh5uCFmpecdc-_PtyCEp.md

@@ -0,0 +1,7 @@
+# Complex
+
+Complex numbers combine a real and imaginary part, written in R as something like `3+2i`. They come up in specialized mathematical work, such as signal processing, but most day-to-day data analysis never touches them directly. R supports them fully as a native type, including arithmetic and functions like `Mod()` and `Conj()`.
+
+Visit the following resources to learn more:
+
+- [@article@Complex Types](https://www.r-tutor.com/r-introduction/basic-data-types/complex)

roadmaps/r-programming/content/conditional-statements@bN3DAVH9lstsgwFhFMU_m.md

@@ -0,0 +1,9 @@
+# Conditional Statements
+
+Conditional statements let code branch based on whether something is true or false, using `if`, `else if`, and `else`. R evaluates the condition, runs the matching block, and skips the rest. R also offers `ifelse()` and dplyr's `case_when()` for applying conditional logic across an entire column of data at once.
+
+Visit the following resources to learn more:
+
+- [@article@Conditional statements](https://intro2r.com/conditional-statements.html)
+- [@article@R If ... Else](https://www.w3schools.com/r/r_if_else.asp)
+- [@video@Conditional Statements in R (If, Else If, and Else)](https://www.youtube.com/watch?v=YT6OXoTIjOk)

roadmaps/r-programming/content/correlation@IeNMySumbyJdHhORMwmFr.md

@@ -0,0 +1,9 @@
+# Correlation
+
+Correlation measures the strength and direction of a linear relationship between two numeric variables, expressed as a single number between negative one and positive one. A value near positive one means the variables tend to increase together, and near zero means little linear relationship exists. Correlation does not imply causation, and it can miss real relationships that aren't linear in shape.
+
+Visit the following resources to learn more:
+
+- [@article@Correlation and Regression Analysis in R](https://bookdown.org/siju_swamy/Stat_Lab/correlation-and-regression-analysis-in-r.html)
+- [@article@Correlation coefficient and correlation test in R](https://statsandr.com/blog/correlation-coefficient-and-correlation-test-in-r/)
+- [@video@Correlation in R](https://www.youtube.com/watch?v=2yLpEeO0QNc)

roadmaps/r-programming/content/cran@IL0fFEs4CgK_eBft-SYAl.md

@@ -0,0 +1,7 @@
+# CRAN
+
+CRAN, the Comprehensive R Archive Network, is R's official package repository, hosting tens of thousands of vetted packages. Packages published on CRAN go through basic automated checks before release, giving them a baseline level of reliability. It's the default source `install.packages()` pulls from, and most tutorials assume packages come from here unless stated otherwise.
+
+Visit the following resources to learn more:
+
+- [@official@CRAN](https://cran.r-project.org/)

roadmaps/r-programming/content/creating-variables@WBnsgWCiduh03uxGIN69c.md

@@ -0,0 +1,8 @@
+# Creating Variables
+
+Creating a variable stores a value under a name so you can reuse it later, most commonly using the `<-` assignment operator, though `=` also works in most contexts. Once assigned, a variable holds its value until you reassign or remove it. This is one of the very first things you do in any R script.
+
+Visit the following resources to learn more:
+
+- [@article@R Variables](https://www.w3schools.com/r/r_variables.asp)
+- [@video@Creating Variables in R](https://www.youtube.com/watch?v=FmK79_MgO-8)

roadmaps/r-programming/content/csv@0cq7ItNudoIj48xoeA-q5.md

@@ -0,0 +1,9 @@
+# CSV
+
+CSV files store tabular data as plain text with values separated by commas, making them one of the most universal formats for exchanging data between tools. Base R can read them with `read.csv()`, though readr's `read_csv()` is faster and handles more edge cases well, such as inconsistent column types or unusual encodings. Reading them correctly means paying attention to details like headers and how missing values are represented.
+
+Visit the following resources to learn more:
+
+- [@article@Reading a CSV file in R](https://www.sfu.ca/~mjbrydon/tutorials/BAinR/data.html#reading-a-csv-file)
+- [@article@How to Import CSV Files into R?](https://www.r-bloggers.com/2022/01/how-to-import-csv-files-into-r/)
+- [@video@Importing a .csv file to R Studio using the read.csv function](https://www.youtube.com/watch?v=oRaPjJefoTo)

roadmaps/r-programming/content/dashboards@ofS4vY5u64GP4mI8gG_WD.md

@@ -0,0 +1,7 @@
+# Dashboards
+
+Dashboards present data and analysis interactively, typically through a web page with charts, filters, and controls a viewer can adjust themselves. They're built either through general business intelligence tools or R-native frameworks, depending on the audience and existing tooling in an organization. This section covers both routes for building them out of R work.
+
+Visit the following resources to learn more:
+
+- [@article@Dashboards con R Markdown](https://epirhandbook.com/es/new_pages/flexdashboard.es.html)

roadmaps/r-programming/content/data-cleaning@dLatbMJKRRZKjQbKW291i.md

@@ -0,0 +1,10 @@
+# Data Cleaning
+
+Data cleaning means fixing messy, inconsistent, or incomplete data before it's ready for analysis. It includes converting types, cleaning text, handling missing values, and detecting outliers.
+
+Visit the following resources to learn more:
+
+- [@article@Cleaning data and core functions](https://epirhandbook.com/en/new_pages/cleaning.html)
+- [@article@Learn R: Data Cleaning Cheatsheet](https://www.codecademy.com/learn/learn-r/modules/learn-r-data-cleaning/cheatsheet)
+- [@article@Best Practices for Data Cleaning and Preprocessing](https://www.r-bloggers.com/2023/08/best-practices-for-data-cleaning-and-preprocessing/)
+- [@video@Data Cleaning With R](https://www.youtube.com/playlist?list=PLBnFxG6owe1HeSD3ICbWuciHXw6VkkpC4)

roadmaps/r-programming/content/data-frames@kIXf6FI-z6dgUdTGCjHkt.md

@@ -0,0 +1,8 @@
+# Data Frames
+
+A data frame is R's standard structure for tabular data, organized into rows and columns where each column can hold a different type but all values within a column share the same type. It's the structure you'll use for almost any real dataset loaded into R, whether from a CSV file, a database, or an API. Nearly every data manipulation package in R, including dplyr, is built around working with data frames or their variants.
+
+Visit the following resources to learn more:
+
+- [@article@R Data Frames](https://www.w3schools.com/r/r_data_frames.asp)
+- [@video@R Tutorial - Using the Data Frame in R](https://www.youtube.com/watch?v=9f2g7RN5N0I)

roadmaps/r-programming/content/data-manipulation@vP5oSvl3Z5inZEd3pmiMK.md

@@ -0,0 +1,3 @@
+# Data Manipulation
+
+Manipulating data means filtering, grouping, joining, and reshaping it once it's already loaded into R. Most of the real work in an analysis happens here, between importing raw data and producing final results.

roadmaps/r-programming/content/data-structures@JTDhohoC6Ew7uvPwuWr1v.md

@@ -0,0 +1,9 @@
+# Data Structures
+
+R holds data in a small set of structures: vectors, lists, and various tabular formats like data frames. Nearly everything done in R involves working with one of these.
+
+Visit the following resources to learn more:
+
+- [@article@R Data Structures](https://www.w3schools.com/r/r_data_structures.asp)
+- [@article@Basic Data Structures in R: Vectors, Matrices, and Data Frames](https://www.r-bloggers.com/2025/01/basic-data-structures-in-r-vectors-matrices-and-data-frames/)
+- [@video@BASIC DATA STRUCTURES IN R PROGRAMMING](https://www.youtube.com/watch?v=k0zLwDAQ6Uw)

roadmaps/r-programming/content/data-tables@SCW3xD7wCf3_ruTtxBkAX.md

@@ -0,0 +1,9 @@
+# Data Tables
+
+A data table is the structure provided by the data.table package, built specifically for fast, memory-efficient operations on large datasets. It extends the data frame with a more concise syntax and internal optimizations that make filtering, grouping, and joining noticeably faster on big data. Many R users learn dplyr first and pick up data tables specifically when performance on large datasets becomes a bottleneck.
+
+Visit the following resources to learn more:
+
+- [@article@Introduction to data.table](https://cran.r-project.org/web/packages/data.table/vignettes/datatable-intro.html)
+- [@article@DT: An R interface to the DataTables library](https://rstudio.github.io/DT/)
+- [@video@data.table Package in R](https://www.youtube.com/playlist?list=PLu6UwBFCnlEcb47DE-yWPjoEeZp10PDJz)

roadmaps/r-programming/content/data-types@Iw6aTwdfOys4mzozQ_2Hz.md

@@ -0,0 +1,8 @@
+# Data Types
+
+R organizes values into a handful of basic types: numbers, text, and logical values, among others. Every piece of data in R falls into one of these categories, and knowing them shapes how code is written and debugged.
+
+Visit the following resources to learn more:
+
+- [@article@R Data Types](https://intro2r.com/data-types.html)
+- [@article@Data types in R programming](https://www.youtube.com/watch?v=VtUVQWl0aRA)

roadmaps/r-programming/content/debugging@1shfOZKx1DfYAOtQb1CoK.md

@@ -0,0 +1,9 @@
+# Debugging
+
+Debugging means finding out why code isn't behaving as expected, using tools like `browser()`, which pauses execution at a specific line so you can inspect variables, and `traceback()`, which shows the sequence of function calls leading up to an error. RStudio and Positron both provide visual debugging tools built on top of these, including breakpoints you can set by clicking in the editor. Print statements remain a simple and effective debugging tool for many everyday issues.
+
+Visit the following resources to learn more:
+
+- [@article@Debugging](https://adv-r.hadley.nz/debugging.html)
+- [@article@Debugging with the RStudio IDE](https://support.posit.co/hc/en-us/articles/205612627-Debugging-with-the-RStudio-IDE)
+- [@video@Introduction to the RStudio Debugger](https://www.youtube.com/watch?v=QQxTf3o07NU)

roadmaps/r-programming/content/descriptive-statistics@epfsRqEvWDjgeSrku0emD.md

@@ -0,0 +1,9 @@
+# Descriptive Statistics
+
+Descriptive statistics summarize the basic characteristics of a dataset: central tendency, spread, and shape. They form the foundation for almost every deeper statistical technique, since you need to understand a variable's basic behavior before modeling relationships involving it. R's base `summary()` function calculates several of these at once for a quick overview.
+
+Visit the following resources to learn more:
+
+- [@article@Descriptive statistics in R](https://statsandr.com/blog/descriptive-statistics-in-r/)
+- [@video@Descriptive Statistics in R Tutorial](https://www.youtube.com/playlist?list=PLu6UwBFCnlEdeJg21seDkYomXz3gt8uAQ)
+- [@video@Calculating Descriptive Statistics of Data in R](https://www.youtube.com/watch?v=UwnrWyuNYxA)

roadmaps/r-programming/content/distribution-analysis@52p2OUjL11aRM4PyHrCt_.md

@@ -0,0 +1,8 @@
+# Distribution Analysis
+
+Distribution analysis looks at how values in a dataset are spread across their range, most commonly using histograms and boxplots. A histogram groups values into bins and shows how many observations fall into each, revealing shape characteristics like skewness. A boxplot summarizes a distribution's median, quartiles, and potential outliers in a single compact visual.
+
+Visit the following resources to learn more:
+
+- [@article@Exploring Data Distribution in R: A Comprehensive Guide](https://www.r-bloggers.com/2023/08/exploring-data-distribution-in-r-a-comprehensive-guide/)
+- [@video@Visualizing Statistical Distributions in R](https://www.youtube.com/watch?v=qG7hByQnzuY)

roadmaps/r-programming/content/dplyr@2EXfdeT4WoEg5ZNr9eCtK.md

@@ -0,0 +1,10 @@
+# dplyr
+
+dplyr provides a small set of verbs for the most common data manipulation tasks: filtering rows, selecting columns, arranging order, and summarizing groups. These verbs are designed to read almost like plain English, making dplyr code easier to follow than equivalent base R code. It's the core data manipulation package within the tidyverse.
+
+Visit the following resources to learn more:
+
+- [@official@dplyr](https://dplyr.tidyverse.org/)
+- [@official@Introduction to dplyr](https://dplyr.tidyverse.org/articles/dplyr.html)
+- [@video@dplyr: Getting Started](https://www.youtube.com/watch?v=THGFXV4RW8U&list=PLiC1doDIe9rC8RgWPAWqDETE-VbKOWfWl)
+- [@video@Manipulate and clean your data in R with the dplyr package](https://www.youtube.com/watch?v=uoqFm1Jyyvw)

roadmaps/r-programming/content/dropping-vs-imputing@xIS0cJ8ui0siBoZJr3-B_.md

@@ -0,0 +1,9 @@
+# Dropping vs. Imputing
+
+Once missing values are found, you have to decide whether to drop rows containing them, which is simple but can lose real information, or impute them, replacing missing values with an estimate like the column mean. The right choice depends heavily on why the data is missing and how much of it there is. Dropping too aggressively can bias results if the missingness isn't random.
+
+Visit the following resources to learn more:
+
+- [@article@Missing values](https://r4ds.hadley.nz/missing-values.html)
+- [@article@A Complete Guide to Handling Missing Values in R: Concepts, Pitfalls, and Practical Imputation with mice](https://dev.to/dipti_moryani_08e62702314/a-complete-guide-to-handling-missing-values-in-r-concepts-pitfalls-and-practical-imputation-with-3b7l)
+- [@video@Handling Missing Data and Missing Values in R Programming](https://www.youtube.com/watch?v=kIKg5s_jDAk)

roadmaps/r-programming/content/encoding-categories@1bHv3_acNts_BeOn3l6DF.md

@@ -0,0 +1,9 @@
+# Encoding Categories
+
+Encoding categories turns text labels into R's factor type, giving categorical data the structure needed for modeling and certain visualizations. It also involves deciding on the order categories should follow, since default alphabetical ordering isn't always meaningful. This step usually comes after the raw text has already been cleaned and standardized.
+
+Visit the following resources to learn more:
+
+- [@article@A guide to encoding categorical features using R](https://www.r-bloggers.com/2020/02/a-guide-to-encoding-categorical-features-using-r/)
+- [@article@Encoding Categorical Data](https://www.tmwr.org/categorical)
+- [@video@R - Studio - Encode Categorical data](https://www.youtube.com/watch?v=Q0XsIPM4UWA)

roadmaps/r-programming/content/error-handling@bLZXJOMu6-NT2bqntOPfd.md

@@ -0,0 +1,9 @@
+# Error Handling
+
+Error handling is the practice of catching and responding to problems in code instead of letting them crash a script outright. `tryCatch()` lets code that might fail specify what should happen if it does, such as logging a message or returning a default value, which matters for anything depending on unreliable inputs like files or APIs.
+
+Visit the following resources to learn more:
+
+- [@article@Catch Me If You Can: Exception Handling in R](https://www.r-bloggers.com/2023/11/catch-me-if-you-can-exception-handling-in-r/)
+- [@article@Error Handling and Generation](https://bookdown.org/rdpeng/RProgDA/error-handling-and-generation.html)
+- [@video@R Tutorial Playlist - Error handler, try catch statement](https://www.youtube.com/watch?v=ShGJy5beTJo)

roadmaps/r-programming/content/excel@SOdl-8SpW1NsQoPtviJ8-.md

@@ -0,0 +1,9 @@
+# Excel
+
+Excel files store data in a binary or XML-based format that differs from plain text files, often including multiple sheets and formatting within a single file. R doesn't read them with base functions, so packages like readxl are needed to extract the underlying data into a usable data frame. Reading Excel data means deciding which sheet to read and whether the first row contains headers.
+
+Visit the following resources to learn more:
+
+- [@article@Read Excel Files in R: readxl & openxlsx](https://www.datanovia.com/learn/programming/importing-exporting-data/read-excel-files-in-r)
+- [@video@Reading and Importing Excel Files Into R With readxl](https://www.youtube.com/watch?v=YxPpNe1UufU)
+- [@video@How to import data from Excel files to R | R Programming](https://www.youtube.com/watch?v=q66Gk-DPBh4)

roadmaps/r-programming/content/exploratory-data-analysis@s2Wxtvjjz7bYK0sYeNhM4.md

@@ -0,0 +1,9 @@
+# Exploratory Data Analysis
+
+Exploratory data analysis is the first, applied pass at understanding a new dataset: summarizing it numerically and visually before any deeper modeling. It usually comes right after cleaning and right before more formal statistical analysis.
+
+Visit the following resources to learn more:
+
+- [@article@Exploratory Data Analysis](https://r4ds.had.co.nz/exploratory-data-analysis.html)
+- [@article@Exploratory Data Analysis in R: A Practical Workflow](https://www.datanovia.com/blog/exploratory-data-analysis-in-r)
+- [@video@Exploratory Data Analysis in R: Towards Data Understanding](https://www.youtube.com/watch?v=JW5Ug6NQexg)

roadmaps/r-programming/content/faceting--themes@P0NtCbzyGWz5B41feWsAy.md

@@ -0,0 +1,10 @@
+# Faceting & Themes
+
+Faceting splits a single plot into a grid of smaller plots, one for each level of a categorical variable, making it easy to compare patterns across groups side by side. Themes control the overall visual styling of a plot, like background color, gridlines, and font sizes. Together they cover much of the difference between a rough exploratory plot and one polished enough to share.
+
+Visit the following resources to learn more:
+
+- [@article@Lay out panels in a grid](https://ggplot2.tidyverse.org/reference/facet_grid.html)
+- [@article@Faceting](https://ggplot2-book.org/facet.html)
+- [@article@Complete themes](https://ggplot2.tidyverse.org/reference/ggtheme.html)
+- [@video@Advanced ggplot - using facets](https://www.youtube.com/watch?v=sxknFa1rprY)

roadmaps/r-programming/content/factors@GeyQm1ONhk_eLXME7OS4M.md

@@ -0,0 +1,9 @@
+# Factors
+
+A factor represents categorical data, storing a fixed set of possible values called levels, such as "low", "medium", "high". Internally, R stores factors as integers mapped to those level labels, which is more memory-efficient than storing the same category repeatedly as text. Getting factor levels and their order right is a common source of subtle bugs, especially when merging or filtering categorical data.
+
+Visit the following resources to learn more:
+
+- [@article@R Factors](https://www.w3schools.com/r/r_factors.asp)
+- [@article@Factors](https://r4ds.had.co.nz/factors.html)
+- [@video@Factor Variables in R](https://www.youtube.com/watch?v=cspQYQLZbCo)

roadmaps/r-programming/content/filter-query-arrange@6w_sSTw1R5MU2zj2RpO5Z.md

@@ -0,0 +1,9 @@
+# Filter, Query, Arrange
+
+Filtering keeps rows matching a condition, querying more broadly covers selecting the specific subset of data you need, and arranging sorts rows by one or more columns. In dplyr, these map to `filter()` and `arrange()`, both designed to read almost like plain English. Together they cover a large share of everyday data wrangling needs.
+
+Visit the following resources to learn more:
+
+- [@article@select, filter & arrange](https://pharmaverse.github.io/intro-to-r-for-sas-programmers-workshop/dplyr.html)
+- [@video@Manipulate data using the tidyverse: select, filter and mutate.](https://www.youtube.com/watch?v=nRtp7wSEtJA)
+- [@video@Arrange in R - Sort a Dataframe by a Column in R](https://www.youtube.com/watch?v=j7SqaJv-i8k)

roadmaps/r-programming/content/forcats@WVgYRRNpsNXBnz7V9JX29.md

@@ -0,0 +1,9 @@
+# forcats
+
+forcats provides tools for working with factors, R's data type for categorical variables, making common tasks like reordering levels or lumping rare categories together more straightforward than base R. Functions like `fct_reorder()` let you control the order categories appear in in plots and tables, which matters since default factor ordering is often alphabetical rather than meaningful. It's especially useful when preparing categorical data for visualization.
+
+Visit the following resources to learn more:
+
+- [@official@Introduction to forcats](https://forcats.tidyverse.org/articles/forcats.html)
+- [@video@Using the forcats package to manipulate factor variables.](https://www.youtube.com/watch?v=AClIvVfqspY)
+- [@video@Working with factors and categorical variables](https://www.youtube.com/watch?v=26US5GD_6-s)

roadmaps/r-programming/content/forward--backward-fill@9mFT0z5yT446_-nGdG492.md

@@ -0,0 +1,8 @@
+# Forward / Backward Fill
+
+Forward and backward fill are common in time series data, carrying the last known value forward or the next known value backward to fill gaps. This assumes a value likely stayed the same or is reasonably close to nearby recorded values. It's a simpler alternative to statistical imputation, often used when data is missing due to something like a sensor briefly going offline.
+
+Visit the following resources to learn more:
+
+- [@article@Fill in missing values with previous or next value](https://tidyr.tidyverse.org/reference/fill.html)
+- [@article@Last observation carried forward](https://r4ds.hadley.nz/missing-values.html#last-observation-carried-forward)

roadmaps/r-programming/content/functions@GrKgIYLzkSjtXdK5czN2x.md

@@ -0,0 +1,10 @@
+# Functions
+
+A function packages a piece of logic under a name so it can be reused without repeating code. Writing and using functions well, including how they accept inputs and return values, is central to structuring any real R project.
+
+Visit the following resources to learn more:
+
+- [@article@R Functions](https://www.w3schools.com/r/r_functions.asp)
+- [@article@Functions](https://r4ds.had.co.nz/functions.html)
+- [@video@A tutorial for writing functions in R](https://www.youtube.com/watch?v=3uK1OzA7CTs)
+- [@video@Create functions in R](https://www.youtube.com/watch?v=dCyj1MCOMrw)

roadmaps/r-programming/content/geospatial-analysis@f2NsSRl_UukuqHggghWSw.md

@@ -0,0 +1,9 @@
+# Geospatial Analysis
+
+Geospatial analysis works with data tied to specific locations on Earth, using specialized structures and tools for handling coordinates, boundaries, and spatial relationships. It covers both vector data, like points and polygons, and raster data, like satellite imagery. This is a distinct application area requiring its own set of packages beyond standard data manipulation tools.
+
+Visit the following resources to learn more:
+
+- [@article@Introduction to geospatial data analysis in R](https://pmarchand1.github.io/atelier_rgeo/rgeo_workshop.html)
+- [@article@An Introduction to Spatial Data Analysis and Visualisation in R](https://data.geods.ac.uk/dataset/an-introduction-to-spatial-data-analysis-and-visualisation-in-r)
+- [@video@Geospatial Data in R](https://www.youtube.com/playlist?list=PLD8eCxFKntVHGCOTs6Cvo_EAp1Xh-yVoQ)

roadmaps/r-programming/content/ggplot2@4FPrICo0eUAONFvObktqU.md

@@ -0,0 +1,9 @@
+# ggplot2
+
+ggplot2 is the tidyverse's plotting package, built around the grammar of graphics, which describes any plot as a combination of data, a coordinate system, and layered elements mapped to aesthetics like position or color. Instead of choosing a fixed chart type, you build a plot by combining these pieces, which is why the same approach can produce scatterplots, bar charts, or complex faceted layouts. It's the standard tool for data visualization in modern R.
+
+Visit the following resources to learn more:
+
+- [@official@Introduction to ggplot2](https://ggplot2.tidyverse.org/articles/ggplot2.html)
+- [@article@A ggplot2 Tutorial for Beautiful Plotting in R](https://www.cedricscherer.com/2019/08/05/a-ggplot2-tutorial-for-beautiful-plotting-in-r/)
+- [@video@ggplot for plots and graphs.](https://www.youtube.com/watch?v=HPJn1CMvtmI&list=PLtL57Fdbwb_C6RS0JtBojTNOMVlgpeJkS)

roadmaps/r-programming/content/ggplot2@vsqvOoq59aWgGexOSwlFG.md

@@ -0,0 +1,9 @@
+# ggplot2
+
+ggplot2 is a data visualization package that follows the grammar of graphics, a system for describing and building graphs by combining independent components. It allows users to create complex plots by layering elements such as data, coordinate systems, and visual mappings. By providing a consistent and structured approach to plotting, it enables the creation of publication-quality visualizations through a series of intuitive, additive commands.
+
+Visit the following resources to learn more:
+
+- [@article@Introduction to ggplot2](https://ggplot2.tidyverse.org/articles/ggplot2.html)
+- [@video@ggplot Tutorials](https://www.youtube.com/playlist?list=PLBnFxG6owe1HRvUL6A5QNF_8ujP8NdLMc)
+- [@video@An introduction to data visualization using R programming](https://www.youtube.com/watch?v=HPJn1CMvtmI)

roadmaps/r-programming/content/grammar-of-graphics@lEiv0DXeWD7w67GdZdy54.md

@@ -0,0 +1,9 @@
+# Grammar of Graphics
+
+The grammar of graphics is the conceptual framework ggplot2 is built on, describing any plot as a combination of data, a coordinate system, and layered geometric elements mapped to aesthetics. Instead of choosing a fixed chart type, you build a plot by combining these pieces, which is why the same underlying approach can produce scatterplots, bar charts, or complex layouts using consistent syntax. Understanding this grammar is what makes ggplot2 code readable and predictable once you know the pattern.
+
+Visit the following resources to learn more:
+
+- [@article@The Grammar of Graphics](https://bookdown.org/gavinmasterson/dvfc/the-grammar-of-graphics.html)
+- [@article@Grammar of Graphics](https://ramnathv.github.io/pycon2014-r/visualize/ggplot2.html)
+- [@video@A Grammar of Graphics](https://www.youtube.com/watch?v=RCaFBJWXfZc)

roadmaps/r-programming/content/group-by--summarize@fuAX0fNChwliVC_gJ7GV2.md

@@ -0,0 +1,9 @@
+# Group By & Summarize
+
+Grouping splits a data frame into groups based on one or more columns, and summarizing then collapses each group down to a single summary row, such as a group's average or count. Together they replace the need for manual loops when calculating statistics per category, like average sales per region. This pattern is one of the most commonly used in all of data analysis.
+
+Visit the following resources to learn more:
+
+- [@article@Summarise each group down to one row](https://dplyr.tidyverse.org/reference/summarise.html)
+- [@article@How to Group and Summarize Data in R](https://www.r-bloggers.com/2022/06/how-to-group-and-summarize-data-in-r/)
+- [@video@Group by and Summarise functions in R programming](https://www.youtube.com/watch?v=XoApM8QrPl8)

roadmaps/r-programming/content/hypothesis-testing@0xYk_O7rNoy7O116xVJvi.md

@@ -0,0 +1,8 @@
+# Hypothesis Testing
+
+Hypothesis testing provides a formal framework for deciding whether an observed pattern in data is likely real or could plausibly have occurred by chance alone. It starts with a null hypothesis, typically stating there's no effect, and calculates a p-value representing how surprising the observed data would be if that null hypothesis were true. Common tests include the t-test for comparing means and the chi-square test for categorical relationships.
+
+Visit the following resources to learn more:
+
+- [@article@Hypothesis Testing in R](https://www.r-bloggers.com/2024/01/hypothesis-testing-in-r-elevating-your-data-analysis-skills/)
+- [@video@Hypothesis testing in R](https://www.youtube.com/watch?v=oNpfjcIf2Es)

roadmaps/r-programming/content/igraph@WA-oBafJlw5OUphYrDm5u.md

@@ -0,0 +1,9 @@
+# igraph
+
+igraph is the standard R package for building, analyzing, and visualizing network graphs. It provides tools for calculating centrality measures, detecting communities, and computing paths between nodes, covering most of the core graph theory operations needed. It's the foundation many other network analysis tools in R, including tidygraph, build on top of.
+
+Visit the following resources to learn more:
+
+- [@official@igraph](https://r.igraph.org/)
+- [@article@igraph guide](https://robwiederstein.github.io/network_analysis/igraph.html)
+- [@video@Statistical network analysis in R (igraph) and Python](https://www.youtube.com/watch?v=yhRvta6mGnQ)

roadmaps/r-programming/content/importing-data@KrX28-WcpfMiuvPBtHAXw.md

@@ -0,0 +1,9 @@
+# Importing Data
+
+Importing data means getting information from outside sources into R, whatever form it originally takes. Flat files, spreadsheets, web pages, and APIs each need a different approach to load correctly.
+
+Visit the following resources to learn more:
+
+- [@article@Importing Data](https://intro2r.com/importing-data.html)
+- [@article@Importing Data Files into R](https://libguides.chapman.edu/R/import)
+- [@video@How to import data and install packages.](https://www.youtube.com/watch?v=e8B9YU_M5FM)

roadmaps/r-programming/content/installing-packages@_4619gNlgw_dDr_fVZ7Up.md

@@ -0,0 +1,10 @@
+# Installing Packages
+
+Installing packages adds functionality to R beyond what comes built in, using the base function `install.packages()` to download and install from CRAN. Running `install.packages("dplyr")`, for example, fetches the dplyr package and its dependencies. This is the most basic and common way to extend R with new capabilities.
+
+Visit the following resources to learn more:
+
+- [@article@Installing and loading packages](https://rladiessydney.org/courses/01-basicbasics-2)
+- [@article@R packages](https://intro2r.com/packages.html)
+- [@article@The Easy Way to Install a Package in R (with 8 Code Examples)](https://www.dataquest.io/blog/install-package-r/)
+- [@video@Installing Packages in R Studio](https://www.youtube.com/watch?v=u1r5XTqrCTQ)

roadmaps/r-programming/content/installing-r@8sLFw8BlwuE7tvMrDg9Pp.md

@@ -0,0 +1,10 @@
+# Installing R
+
+Installing R involves downloading the base software environment from the Comprehensive R Archive Network (CRAN) and executing the installer for your specific operating system. This process sets up the core language engine, allowing you to run R scripts, manage packages, and perform statistical computations directly on your computer. Once the installation is complete, you can interact with the language through the default console or by using an integrated development environment like Positron or RStudio.
+
+Visit the following resources to learn more:
+
+- [@article@Installing R](https://intro2r.com/install_r.html)
+- [@article@Installing R and RStudio](https://rstudio-education.github.io/hopr/starting.html)
+- [@video@R Programming Tutorial - Learn the Basics of Statistical Computing](https://www.youtube.com/watch?v=_V8eKsto3Ug)
+- [@video@How to install R and RStudio on Windows 11 (Updated 2025)](https://www.youtube.com/watch?v=mxNrU902uyc)

roadmaps/r-programming/content/integer@K1whVa9-2i8QMqDo_tNlZ.md

@@ -0,0 +1,7 @@
+# Integer
+
+Integers are whole numbers stored more compactly than numeric values, created by appending an `L` to a number, like `5L`. They matter when memory efficiency counts, since integers take up less space than numeric doubles. Most everyday R code doesn't need to worry about the distinction, since R converts between the two automatically in most operations.
+
+Visit the following resources to learn more:
+
+- [@article@Integers](https://statsandr.com/blog/data-types-in-r/#integer)

roadmaps/r-programming/content/interactive-plots@BMWA2CF4VkXEneErhJym-.md

@@ -0,0 +1,7 @@
+# Interactive Plots
+
+Interactive plots let viewers hover over points for details, zoom into a region, or toggle categories on and off, rather than viewing a fixed, static image. They work particularly well in dashboards, reports viewed in a browser, or any context where the audience benefits from exploring the data themselves. They aren't useful for print or contexts where the output needs to be a fixed image.
+
+Visit the following resources to learn more:
+
+- [@article@https://medium.com/codetodeploy/data-visualization-with-r-creating-interactive-dashboards-1a7f0634346d](https://medium.com/codetodeploy/data-visualization-with-r-creating-interactive-dashboards-1a7f0634346d)

roadmaps/r-programming/content/introduction@QUzLkB8iKfUBtyAfKc8LC.md

@@ -0,0 +1,10 @@
+# What is R
+
+R is a programming language built for statistical computing and data analysis. Bell Labs statisticians created its predecessor, S, in the 1970s, and R emerged in the 1990s as an open-source implementation of similar ideas. It comes with built-in support for vectors, data frames, and statistical functions, so tasks like regression or plotting a distribution take just a line or two of code. Universities, pharmaceutical companies, and data science teams use it heavily for analysis, visualization, and research reproducibility.
+
+Visit the following resources to learn more:
+
+- [@official@Introduction to R](https://www.r-project.org/about.html)
+- [@article@R Introduction](https://www.w3schools.com/r/r_intro.asp)
+- [@article@What Is R Programming? Definition, Use Cases and FAQ](https://www.coursera.org/articles/what-is-r-programming)
+- [@video@R programming for ABSOLUTE beginners](https://www.youtube.com/watch?v=FY8BISK5DpM)

roadmaps/r-programming/content/iqr@ucEFYVtXIvuYKjudK3pwB.md

@@ -0,0 +1,8 @@
+# IQR
+
+The IQR method for detecting outliers flags values that fall well below or above the interquartile range, the range between the 25th and 75th percentile of the data. It's a robust approach, less sensitive to extreme values than methods based on the mean and standard deviation. It's commonly visualized directly through a boxplot's whiskers.
+
+Visit the following resources to learn more:
+
+- [@article@Steps to detect outliers using Interquartile range(IQR) with R](https://medium.com/@psrinivasan028/steps-to-detect-outliers-using-interquartile-range-iqr-with-r-1f9ed7895d96)
+- [@article@Outliers detection in R](https://statsandr.com/blog/outliers-detection-in-r/)

roadmaps/r-programming/content/isnull-isna@bcODvfBqCUwLVXa8HKOFB.md

@@ -0,0 +1,9 @@
+# isnull, isna
+
+Detecting missing values in R relies on `is.na()`, since direct comparison like `NA == NA` doesn't return `TRUE` the way you might expect. This function returns a logical vector marking which values are missing, which can then be summed to count them or used to filter rows. It's the starting point before deciding how to handle any missing data found.
+
+Visit the following resources to learn more:
+
+- [@article@Missing values](https://r4ds.hadley.nz/missing-values.html)
+- [@article@R null values: NULL, NA, NaN, Inf](https://www.r-bloggers.com/2018/07/r-null-values-null-na-nan-inf/)
+- [@video@Handling NA in R | is.na, na.omit & na.rm Functions for Missing Values](https://www.youtube.com/watch?v=q8eR2suCyGk)

roadmaps/r-programming/content/joins@WdiPYzeuO8dKQsuP0xy4P.md

@@ -0,0 +1,9 @@
+# Joins
+
+Joins combine two data frames based on matching values in one or more shared columns, similar to joins in SQL. An inner join keeps only rows with matches in both tables, a left join keeps all rows from the first table and fills in matches where available, and a full join keeps all rows from both regardless of matches. Choosing the right join type is essential whenever data is spread across multiple related tables.
+
+Visit the following resources to learn more:
+
+- [@article@Joins](https://r4ds.hadley.nz/joins.html)
+- [@article@Mutating joins](https://dplyr.tidyverse.org/reference/mutate-joins.html)
+- [@video@Join Data with dplyr in R (6 Examples)](https://www.youtube.com/watch?v=Yg-pNqzDuN4)

roadmaps/r-programming/content/json@R_8vJSp2Zp0CBWMeI2gsd.md

@@ -0,0 +1,9 @@
+# JSON
+
+JSON is a structured text format built around nested key-value pairs, commonly returned by web APIs. Parsing it in R usually means using a package like jsonlite to convert the response into R data structures. Because JSON's nested structure often doesn't map directly onto a flat data frame, some restructuring is usually needed afterward to get it into a usable tabular shape.
+
+Visit the following resources to learn more:
+
+- [@article@Processing JSON data](https://datacarpentry.github.io/r-socialsci/07-json.html)
+- [@article@How to read JSON files in R](https://www.educative.io/answers/how-to-read-json-files-in-r)
+- [@video@Read JSON Data into R](https://www.youtube.com/watch?v=ngALTXed0F0)

roadmaps/r-programming/content/leaflet@2uHsp_MQMF3WaOgcv0eDY.md

@@ -0,0 +1,9 @@
+# leaflet
+
+leaflet creates interactive, web-based maps in R, built on top of the popular Leaflet.js JavaScript library. Unlike static maps, leaflet maps let viewers pan, zoom, and click on individual features to see more detail. It integrates well with Shiny apps, letting map interactions trigger updates elsewhere in a dashboard.
+
+Visit the following resources to learn more:
+
+- [@article@An R Interface to Leaflet Maps](https://rstudio.github.io/leaflet/)
+- [@article@Interactive Maps with leaflet in R](https://r-graph-gallery.com/package/leaflet.html)
+- [@video@R Leaflet package | R Leaflet Tutorial](https://www.youtube.com/playlist?list=PL6wLL_RojB5y8uL3uuIMnJ6JoTIFywQ-r)

roadmaps/r-programming/content/linear-regression@PMGbX81TpodkDVz8o1z-T.md

@@ -0,0 +1,9 @@
+# Linear Regression
+
+Linear regression models the relationship between a numeric outcome and one or more predictor variables, fitting a straight line, or hyperplane with multiple predictors, that best describes the relationship. R's `lm()` function fits linear models with a simple formula syntax, like `lm(sales ~ advertising)`. Checking the model's assumptions, like linearity and constant variance of the errors, matters for trusting its results.
+
+Visit the following resources to learn more:
+
+- [@article@Linear regression in R](https://developer.ibm.com/tutorials/awb-linear-regression-in-r/)
+- [@article@How to Do Linear Regression in R](https://www.datacamp.com/tutorial/linear-regression-R)
+- [@video@Linear regression using R programming](https://www.youtube.com/watch?v=-mGXnm0fHtI)

roadmaps/r-programming/content/lists@lbYcKVjKw1mMU1DIGwA-s.md

@@ -0,0 +1,8 @@
+# Lists
+
+A list is a flexible container that can hold elements of different types and lengths in a single object, unlike a vector, which requires uniform type. A single list might hold a character string, a numeric vector, and a data frame all at once. Accessing elements typically uses double brackets, `[[ ]]`, to pull out a single element, versus single brackets, `[ ]`, which return a sublist.
+
+Visit the following resources to learn more:
+
+- [@article@R Lists](https://www.w3schools.com/r/r_lists.asp)
+- [@video@Working with lists in R](https://www.youtube.com/watch?v=X8lNTDeiKiE)

roadmaps/r-programming/content/logical@jQTOs0UfekeCV6sPWVOr2.md

@@ -0,0 +1,7 @@
+# Logical
+
+Logical values represent true or false, written as `TRUE` and `FALSE`. They result from comparisons like `5 > 3` and drive conditional logic throughout R code, such as `if` statements and filtering rows in a data frame. Logical values can also be summed directly, since R treats `TRUE` as 1 and `FALSE` as 0 in numeric contexts.
+
+Visit the following resources to learn more:
+
+- [@article@R Booleans / Logical Values](https://www.w3schools.com/r/r_booleans.asp)

roadmaps/r-programming/content/logistic-regression@nfuMTLrkI-XSNDseEOkXD.md

@@ -0,0 +1,9 @@
+# Logistic Regression
+
+Logistic regression models a binary outcome, like whether an event happens or not, as a function of one or more predictor variables. It predicts the probability of the outcome falling into one category, using the `glm()` function with a logistic link in R. It's one of the most widely used models for classification problems, both in traditional statistics and as a baseline in machine learning.
+
+Visit the following resources to learn more:
+
+- [@article@Logistic Regression with R](https://bookdown.org/nhanhocumc/biodata-r/logisticr.html)
+- [@article@Logistic Regression in R Tutorial](https://www.datacamp.com/tutorial/logistic-regression-R)
+- [@video@Logistic Regression using R programming](https://www.youtube.com/watch?v=kwLsOsSI9JM)

roadmaps/r-programming/content/loops@mCa0SGe_bHuU5P_FEsNYI.md

@@ -0,0 +1,9 @@
+# Loops
+
+A `for` loop repeats a block of code once for each element in a vector or list. A `while` loop repeats as long as a condition stays true, useful when you don't know in advance how many iterations you'll need. R loops are generally slower than vectorized alternatives, so experienced R users often reach for functions like `sapply()` or dplyr verbs where possible.
+
+Visit the following resources to learn more:
+
+- [@article@R Loops](https://intro2r.com/loops.html)
+- [@article@Loops](https://rstudio-education.github.io/hopr/loops.html)
+- [@video@Loops using R programming](https://www.youtube.com/watch?v=UvopClD98LQ)

roadmaps/r-programming/content/lubridate@aD3VCC-ltZVisOgC--gAd.md

@@ -0,0 +1,10 @@
+# lubridate
+
+lubridate makes working with dates and times considerably easier than base R alone. Functions like `ymd()`, `mdy()`, and `dmy()` parse dates written in different common formats without requiring a manually specified format string. It also provides clear tools for date arithmetic using durations, periods, and intervals, each handling calendar quirks like leap years slightly differently.
+
+Visit the following resources to learn more:
+
+- [@official@lubridate](https://lubridate.tidyverse.org/)
+- [@article@Mastering Date and Time Data in R with lubridate](https://www.r-bloggers.com/2024/09/mastering-date-and-time-data-in-r-with-lubridate/)
+- [@video@Lubridate - how to manipulate date and time data in R](https://www.youtube.com/watch?v=g4JF_Ew8qEc)
+- [@video@lubridate Package Tutorial](https://www.youtube.com/watch?v=Tu-bnBaHpo0&list=PLu6UwBFCnlEel8EaYcRShzIKmh4HcIZZi)

roadmaps/r-programming/content/machine-learning@KWfYpJQwYeQzP4buGaA9y.md

@@ -0,0 +1,8 @@
+# Machine Learning
+
+Machine learning builds predictive and pattern-finding models from data, using R's modern modeling frameworks. It builds directly on the statistical foundations covered earlier in the roadmap.
+
+Visit the following resources to learn more:
+
+- [@article@An Introduction to Machine Learning with R](https://lgatto.github.io/IntroMachineLearningWithR/an-introduction-to-machine-learning-with-r.html)
+- [@video@Machine learning with R](https://www.youtube.com/playlist?list=PLKBUk9FL4nBaHaW7C4_SAQfY_Wf-hupUG)

roadmaps/r-programming/content/map-functions@e4mVEXKmmQbz051wE1HPZ.md

@@ -0,0 +1,9 @@
+# Map Functions
+
+Map functions apply a function to every element of a list or vector and collect the results, avoiding the need for an explicit loop. purrr's `map()` always returns a list, while variants like `map_dbl()` return a vector of a specific type, making the expected output explicit. This becomes especially useful for iterating over nested data, such as running the same model on many subsets of a dataset at once.
+
+Visit the following resources to learn more:
+
+- [@article@Mastering the map() Function in R: A Comprehensive Guide](https://www.r-bloggers.com/2024/03/mastering-the-map-function-in-r-a-comprehensive-guide/)
+- [@article@Functionals in R](https://adv-r.hadley.nz/functionals.html)
+- [@video@Alternative to for loops in R with purrr's map, map_dbl, and map_dfr functions (CC043)](https://www.youtube.com/watch?v=nXQDiCTLTgU)

roadmaps/r-programming/content/matrices@29bAj72LyJQ62JbBl9vvG.md

@@ -0,0 +1,10 @@
+# Matrices
+
+A matrix is a two-dimensional grid of values, all of the same type, arranged in rows and columns. Matrices support standard linear algebra operations like multiplication, transposition, and inversion, making them the natural structure for mathematical computation in R. Unlike a data frame, every cell in a matrix must share the same underlying data type.
+
+Visit the following resources to learn more:
+
+- [@article@R Matrices](https://www.w3schools.com/r/r_matrices.asp)
+- [@article@Understanding Matrices in R Programming](https://www.r-bloggers.com/2023/11/understanding-matrices-in-r-programming/)
+- [@video@Matrices in R](https://www.youtube.com/watch?v=3fHRSAYgRKY)
+- [@video@How to Create Matrices and Perform matrix Operations in R](https://www.youtube.com/watch?v=SYYUBytX1ng)

roadmaps/r-programming/content/mutate--transform@8vgTUVCNPb71lNHKycHce.md

@@ -0,0 +1,9 @@
+# Mutate & Transform
+
+Mutating adds new columns or changes existing ones in a data frame, calculating values across every row based on an expression you specify. Multiple new columns can be created in a single step, with later columns able to reference ones created earlier in the same step. This is one of the most frequently used data manipulation operations, since almost every analysis involves deriving new variables from existing ones.
+
+Visit the following resources to learn more:
+
+- [@article@Create, modify, and delete columns](https://dplyr.tidyverse.org/reference/mutate.html)
+- [@article@dplyr mutate() in R: Create and Transform Columns](https://r-statistics.co/dplyr-mutate-in-R.html)
+- [@video@dplyr: mutate](https://www.youtube.com/watch?v=DKWM3C-fMRA)

roadmaps/r-programming/content/network-analysis@YBcSlradj7221NPcwWcFk.md

@@ -0,0 +1,10 @@
+# Network Analysis
+
+Network analysis studies relationships between entities, represented as a graph of nodes connected by edges, such as people connected by friendships or web pages connected by links. It covers identifying influential nodes, detecting clusters or communities within a network, and visualizing the overall structure. This is a distinct application area from typical tabular data analysis, since relationships between records matter as much as the records themselves.
+
+Visit the following resources to learn more:
+
+- [@article@Network Analysis using R](https://ladal.edu.au/tutorials/network_analysis/network_analysis.html)
+- [@article@Network Analysis in R](https://bookdown.org/jdholster1/idsr/network-analysis.html)
+- [@article@Introduction to Network Analysis Tools in R](https://statnet.org/workshop-intro-sna-tools/)
+- [@video@Social Network Analysis: A Beginner's Lab in R](https://www.youtube.com/playlist?list=PL1M5TsfDV6VsyfMHfkDcUW71ADKcUNCUI)

roadmaps/r-programming/content/nlp@BgwWbX4MgOPwMDPGX_HFs.md

@@ -0,0 +1,10 @@
+# NLP
+
+NLP, or natural language processing, covers techniques for analyzing and extracting meaning from text data, such as tokenizing, measuring sentiment, or discovering topics across a collection of documents. R has a mature set of packages for this kind of work, ranging from tidyverse-friendly tools to faster, more specialized libraries for large text corpora. It's a distinct application area combining string handling with statistical and sometimes machine learning techniques.
+
+Visit the following resources to learn more:
+
+- [@article@Natural Language Processing with R](https://s-ai-f.github.io/Natural-Language-Processing/)
+- [@article@A Guide to Natural Language Processing with R](https://www.r-bloggers.com/2024/01/a-guide-to-natural-language-processing-with-r/)
+- [@video@NLP in R Course](https://www.youtube.com/playlist?list=PLGey__rsxvBXNOv0Yq9jWcgo_iBH_Z9U_)
+- [@video@Text Mining In R](https://www.youtube.com/watch?v=m8r7WtZ0voQ)

roadmaps/r-programming/content/numeric@dewpbYpun6Nho0ErI3rv-.md

@@ -0,0 +1,8 @@
+# Numeric
+
+Numeric is R's default type for numbers with decimal points, such as `3.14` or `2.0`, stored internally as double-precision floating point values. Almost all arithmetic in R produces numeric results unless you explicitly ask for integers. This is the type used for the vast majority of everyday calculations.
+
+Visit the following resources to learn more:
+
+- [@article@Numerics](https://www.w3schools.com/r/r_numbers.asp)
+- [@article@Numeric Types](https://statsandr.com/blog/data-types-in-r/#numeric)

roadmaps/r-programming/content/operators@3d540CG_Ye7vvIFQKmiPb.md

@@ -0,0 +1,8 @@
+# Operators
+
+Arithmetic operators handle basic math, like `+`, `-`, `*`, and `/`. Relational operators compare values and return a logical result, like `==` and `<`. Logical operators combine or invert logical values, using `&` and `|` for element-wise comparisons. These form the backbone of nearly every calculation and condition you write in R.
+
+Visit the following resources to learn more:
+
+- [@article@R Operators](https://www.w3schools.com/r/r_operators.asp)
+- [@video@Operators in R | R for Data Analytics Series](https://www.youtube.com/watch?v=O5nQKzBb0oc)

roadmaps/r-programming/content/overplotting-techniques@1b3AiO9i3pgkglwGeHiqd.md

@@ -0,0 +1,8 @@
+# Overplotting Techniques
+
+Overplotting happens when too many data points overlap on a plot, making it hard to see the true density or pattern, especially common with large datasets. Jittering adds small random noise to point positions to spread out overlapping points slightly. Transparency, adjusted through the alpha setting, lets overlapping points show through each other rather than fully obscuring one another.
+
+Visit the following resources to learn more:
+
+- [@article@Dealing with overplotting](https://bookdown.dongzhuoer.com/hadley/ggplot2-book/overplotting)
+- [@video@Overplotting - Data Analysis with R](https://www.youtube.com/watch?v=DlDQLxYRB4w)

roadmaps/r-programming/content/pak@j1jq5_64lBuYQQjJWKIuI.md

@@ -0,0 +1,8 @@
+# pak
+
+pak is a newer package installer for R designed to replace `install.packages()` with something faster and more reliable. It parallelizes downloads, caches packages locally so reinstalls are quicker, and gives clearer error messages when a dependency conflict occurs. Many R developers now use it as their default installer instead of base R's built-in function.
+
+Visit the following resources to learn more:
+
+- [@official@pak](https://pak.r-lib.org/)
+- [@opensource@pak](https://github.com/r-lib/pak)

roadmaps/r-programming/content/parallel-computing@ApowKoA3C1B8oUr4-sltZ.md

@@ -0,0 +1,9 @@
+# Parallel Computing
+
+Parallel computing splits a computational task across multiple processor cores at once, rather than running everything sequentially, cutting the total time for tasks that can be broken into independent pieces. R provides tools like the parallel package's `parLapply()` for distributing work across a cluster of R processes. Not every task benefits from this, since the overhead of splitting work and combining results can outweigh the benefit for small or fast tasks.
+
+Visit the following resources to learn more:
+
+- [@article@Parallel Computation](https://bookdown.org/rdpeng/rprogdatascience/parallel-computation.html)
+- [@article@Quick Intro to Parallel Computing in R](https://nceas.github.io/oss-lessons/parallel-computing-in-r/parallel-computing-in-r.html)
+- [@video@Parallel Computing in R](https://www.youtube.com/watch?v=_5hXQPTW-wU)

roadmaps/r-programming/content/parsing-dates@L7btVRwvkEVX0K8LxnbqJ.md

@@ -0,0 +1,10 @@
+# Parsing Dates
+
+Parsing dates handles the extra complexity of date formats, since something like "01/02/2024" could mean different things depending on locale conventions. Getting the format specification right, or using a package like lubridate that guesses common formats automatically, avoids silently misreading dates. This matters especially when working with data from different countries or systems that don't agree on date conventions.
+
+Visit the following resources to learn more:
+
+- [@article@Mastering Date and Time Data in R with lubridate](https://www.r-bloggers.com/2024/09/mastering-date-and-time-data-in-r-with-lubridate/)
+- [@article@parse_date: Parse date from any format](https://www.rdocumentation.org/packages/parsedate/versions/1.3.2/topics/parse_date)
+- [@video@Lubridate - how to manipulate date and time data in R](https://www.youtube.com/watch?v=g4JF_Ew8qEc)
+- [@video@Standardizing and Parsing Dates in R using Lubridate](https://www.youtube.com/watch?v=v5jasYkmwZI)

roadmaps/r-programming/content/pipe@0K17RO_EoOaT820WypQ7H.md

@@ -0,0 +1,9 @@
+# Pipe
+
+The pipe operator takes the result on its left and passes it as the first argument to the function on its right, letting you chain several operations in a readable, top-to-bottom sequence. R now has two common versions: the native pipe `|>`, built into base R since version 4.1, and the older magrittr pipe `%>%`, which predates it and is still common in existing code. Writing `data |> filter(x > 0) |> summarize(mean(x))` reads as a sequence of steps rather than a nested jumble of function calls.
+
+Visit the following resources to learn more:
+
+- [@article@R Pipe Operator: %\>% vs |\>, The Complete Guide to Both Pipes](https://r-statistics.co/R-Pipe-Operator.html)
+- [@video@Finally Explained: The Difference Between R's Pipe Operators](https://www.youtube.com/watch?v=uIL9gMjn40Y)
+- [@video@Introducing the Pipe Operator in R](https://www.youtube.com/watch?v=Stt3qEuIeso)

roadmaps/r-programming/content/plotly@XPr7td4S8xpFxG5IkWvyz.md

@@ -0,0 +1,10 @@
+# plotly
+
+plotly creates interactive charts that let viewers hover, zoom, and filter directly in the browser. It can convert many existing ggplot2 plots into interactive versions with a single function call, or build interactive charts directly with its own syntax. It's the most common package in R for adding this kind of interactivity to a plot.
+
+Visit the following resources to learn more:
+
+- [@official@Getting Started](https://plotly.com/r/getting-started/)
+- [@official@Getting Started with Plotly in ggplot2](https://plotly.com/ggplot2/getting-started/)
+- [@opensource@plotly.R](https://github.com/plotly/plotly.R)
+- [@video@R Plotly Tutorial | Plotly in R](https://www.youtube.com/playlist?list=PL6wLL_RojB5y747hFeeYME5nZq2cuaR7E)

roadmaps/r-programming/content/positron@2m8uQRGaVZUd4mfm7bRou.md

@@ -0,0 +1,9 @@
+# Positron
+
+Positron is a newer IDE from Posit, built on the same underlying technology as VS Code but tailored for data science work in R and Python. It combines a modern, extensible editor with the data-focused features R users expect, like a variables pane and integrated plots. It's becoming the default recommendation for new R and data science setups.
+
+Visit the following resources to learn more:
+
+- [@official@Positron](https://positron.posit.co/)
+- [@official@Exploratory Data Analysis with R in Positron](https://posit.co/blog/eda-in-positron)
+- [@video@A quick tour of Positron](https://www.youtube.com/watch?v=4Ir_HX4riHw)

roadmaps/r-programming/content/power-bi--tableau@EHVXO79NGpLC1i8x4Y7g1.md

@@ -0,0 +1,10 @@
+# Power BI / Tableau
+
+Power BI and Tableau are business intelligence tools for building dashboards, connecting to data sources and creating interactive visualizations largely through a visual interface rather than code. R can connect to both, either as a data source feeding into them or, in Power BI's case, running R scripts directly inside the tool for custom visuals or calculations. They're common in organizations where dashboards need to be shared with non-technical stakeholders through a standard business tool.
+
+Visit the following resources to learn more:
+
+- [@article@Connecting Tableau](https://help.tableau.com/current/pro/desktop/en-us/r_connection_manage.htm)
+- [@article@Create Power BI visuals using R](https://learn.microsoft.com/en-us/power-bi/create-reports/desktop-r-visuals)
+- [@video@Intro to R with Power BI](https://www.youtube.com/watch?v=NomSliJK3s4)
+- [@video@Tableau with Python and R](https://www.youtube.com/watch?v=BRAp08PrTTI)

roadmaps/r-programming/content/probability-distributions@wSKItU0lct_9CCs4G4JO_.md

@@ -0,0 +1,10 @@
+# Probability Distributions
+
+A probability distribution describes how likely different outcomes are for a random variable, such as the normal distribution or the binomial distribution for counting successes in repeated trials. R provides functions for common distributions following a consistent naming pattern: `d` for density, `p` for cumulative probability, `q` for quantiles, and `r` for random generation. Understanding which distribution reasonably describes your data underlies many statistical tests and models.
+
+Visit the following resources to learn more:
+
+- [@article@Probability Distributions in R (Stat 5101, Geyer)](https://www.stat.umn.edu/geyer/old/5101/rlook.html)
+- [@article@Basic Probability Distributions in R](https://rpubs.com/ggraham412/100906)
+- [@video@Probability Distributions with R](https://www.youtube.com/playlist?list=PL2czy8u8hfA19CClwzdbEJEG6jccbV0JB)
+- [@video@Introduction to R: Probability Distributions](https://www.youtube.com/watch?v=Rxe086csxTU)

roadmaps/r-programming/content/purrr@KXvrYvFvyAqFbJeS1KHRi.md

@@ -0,0 +1,10 @@
+# purrr
+
+purrr applies a function to each element of a list or vector and collects the results, similar in spirit to base R's apply family but with more consistent, predictable behavior. Its `map()` function always returns a list, while variants like `map_dbl()` return a vector of a specific type, making the expected output explicit. It fits naturally with the pipe operator and tidyverse style, letting you iterate without writing explicit loops.
+
+Visit the following resources to learn more:
+
+- [@official@Get started with purrr](https://purrr.tidyverse.org/articles/purrr.html)
+- [@article@Learn to purrr](https://rebeccabarter.com/blog/2019-08-19_purrr)
+- [@video@How to purrr](https://www.youtube.com/watch?v=nd-Y8b22YaQ)
+- [@video@Hadley Wickham | {purrr}](https://www.youtube.com/watch?v=EGAs7zuRutY&t=11s)

roadmaps/r-programming/content/quanteda@gUpA_YtWlToGs-OJZZDpV.md

@@ -0,0 +1,9 @@
+# quanteda
+
+quanteda is a faster, more powerful text analysis package built for working with large corpora of documents, offering more advanced features than tidytext for tasks like document-feature matrices and topic modeling. It trades some of tidytext's tidyverse-native simplicity for more performance and specialized functionality. It's typically reached for once text analysis needs outgrow what tidytext comfortably handles.
+
+Visit the following resources to learn more:
+
+- [@official@quanteda: Quantitative Analysis of Textual Data](https://quanteda.io/)
+- [@opensource@quanteda](https://github.com/quanteda/quanteda)
+- [@video@Quanteda-1. Introduction to R-package Quanteda](https://www.youtube.com/watch?v=ypMODS_onn0)

roadmaps/r-programming/content/quarto@SnLNFoVZhL6YuE9QOLpAl.md

@@ -0,0 +1,10 @@
+# Quarto
+
+Quarto is a publishing system that renders documents combining text, code, and code output into formats like HTML, PDF, or Word. It works across multiple languages, including R, Python, and Julia, and is positioned as the modern successor to R Markdown. Posit actively develops and promotes it as the current default for literate programming in R.
+
+Visit the following resources to learn more:
+
+- [@official@Quarto](https://quarto.org/)
+- [@official@Quarto for R](https://quarto.org/docs/computations/r.html)
+- [@official@Tutorial: Hello, Quarto](https://quarto.org/docs/get-started/hello/rstudio.html)
+- [@video@Quarto crash course - what you can do with quarto](https://www.youtube.com/watch?v=oYV1a9sWhgM)

roadmaps/r-programming/content/r-dates--times@1X3RbJPY_GbIDarcO2UDL.md

@@ -0,0 +1,10 @@
+# R Dates & Times
+
+Base R represents dates and times using specific classes: `Date` for calendar dates and `POSIXct` for date-times that include a time component. These classes let you do arithmetic directly, like subtracting two dates to get the number of days between them. Parsing dates correctly requires knowing the format they were written in, since ambiguous formats can be misread.
+
+Visit the following resources to learn more:
+
+- [@article@Dates and times](https://r4ds.hadley.nz/datetimes.html)
+- [@article@A Comprehensive Introduction to Handling Date & Time in R](https://www.r-bloggers.com/2020/04/a-comprehensive-introduction-to-handling-date-time-in-r/)
+- [@article@Working with dates](https://epirhandbook.com/en/new_pages/dates.html)
+- [@video@Difference Between Dates in R](https://www.youtube.com/watch?v=rH8l2FOGUbM)

roadmaps/r-programming/content/r-markdown@PDZEvLgi94V5oLt3J5U9Z.md

@@ -0,0 +1,10 @@
+# R Markdown
+
+R Markdown documents mix Markdown-formatted text with chunks of R code, rendering into HTML, PDF, or Word output with the code's results embedded directly. It predates Quarto and was the standard tool for this kind of work for many years, so a large amount of existing documentation and tutorials still use it. Quarto has since become the recommended tool for new projects, but R Markdown remains fully functional and widely used.
+
+Visit the following resources to learn more:
+
+- [@official@R Markdown](https://rmarkdown.rstudio.com/)
+- [@video@R Markdown: The Definitive Guide](https://pkg.yihui.org/rmarkdown-book/)
+- [@video@What is R Markdown?](https://www.youtube.com/watch?v=asHhuHRxhvo)
+- [@video@R Markdown TUTORIAL](https://www.youtube.com/watch?v=K418swtFnik)

roadmaps/r-programming/content/r-vs-python@O3lbX70fDeKsv9fkJJtYv.md

@@ -0,0 +1,10 @@
+# R vs Python for Data Work
+
+R and Python solve overlapping problems but come from different roots. R grew out of statistics departments, so its core language and packages treat data frames, vectors, and statistical models as first-class citizens. Python grew as a general-purpose language, so its data tools (pandas, NumPy) were added on top of a language built for other things. In practice, R tends to win for statistical modeling, academic research, and quick exploratory analysis, while Python wins for production software, deep learning, and general-purpose scripting.
+
+Visit the following resources to learn more:
+
+- [@roadmap@Visit the Dedicated Python For Data Analysis Roadmap](https://roadmap.sh/python-data-analysis)
+- [@article@Python vs. R: What’s the Difference?](https://www.ibm.com/think/topics/python-vs-r)
+- [@article@Python or R for Data Analysis: Which Should You Learn?](https://www.coursera.org/articles/python-or-r-for-data-analysis)
+- [@video@R vs Python](https://www.youtube.com/watch?v=4lcwTGA7MZw&t=171s)

roadmaps/r-programming/content/readr@y0yMev6QSHjqd1YJ9Y05Z.md

@@ -0,0 +1,9 @@
+# readr
+
+readr provides fast, consistent functions for reading flat files like CSVs into R, such as `read_csv()`, as an improvement over base R's equivalent functions. It handles more edge cases well, like inconsistent column types or unusual encodings, and gives clearer feedback about how it parsed each column. It's typically the first tool reached for when loading tabular data into R.
+
+Visit the following resources to learn more:
+
+- [@official@Introduction to readr](https://readr.tidyverse.org/articles/readr.html)
+- [@article@Importing Data into R with readr](https://ehsanx.github.io/intro2R/importing-data-into-r-with-readr.html)
+- [@video@How to handle large files with R using {readr} 2.0](https://www.youtube.com/watch?v=Qby_dGxEQE4)

roadmaps/r-programming/content/recursion@VdtQNeFL8vnaHHzW6CWds.md

@@ -0,0 +1,7 @@
+# Recursion
+
+Recursion is when a function calls itself, typically to break a problem into smaller versions of the same problem until it reaches a simple base case. A classic example is calculating a factorial by having the function call itself with a smaller number each time. Recursive functions need a clear stopping condition, or they will call themselves indefinitely and crash.
+
+Visit the following resources to learn more:
+
+- [@article@R recursion](https://www.w3schools.com/r/r_functions_recursion.asp)

roadmaps/r-programming/content/regular-expressions@feXXBBD1J5TEllq2zbCUZ.md

@@ -0,0 +1,10 @@
+# Regular Expressions
+
+Regular expressions are a pattern-matching language for describing sequences of characters, used to search, validate, or extract specific pieces of text. A pattern like `^\d{3}-\d{4}$` might describe a phone number format, matching only text that fits that exact shape. They take practice to read fluently, but solve text problems that simple string functions alone can't handle efficiently.
+
+Visit the following resources to learn more:
+
+- [@article@Regular expressions in R](https://r4ds.hadley.nz/regexps.html)
+- [@article@Regular expressions](https://stringr.tidyverse.org/articles/regular-expressions.html)
+- [@video@Finally Understand Regular Expressions](https://www.youtube.com/watch?v=IzBk58Eorr4)
+- [@video@Regular Expressions in R language (With Examples)](https://www.youtube.com/watch?v=2XkFY3K3NWE)

roadmaps/r-programming/content/relationship-analysis@hS12KA72tBNmVvS921-H-.md

@@ -0,0 +1,10 @@
+# Relationship Analysis
+
+Relationship analysis examines how two or more variables relate to each other, using tools like scatterplots for two numeric variables, correlation matrices for many numeric variables at once, and cross-tabulation for categorical variables. This is usually the second step in exploratory analysis, after looking at variables individually. It often surfaces the patterns that later motivate a specific statistical model.
+
+Visit the following resources to learn more:
+
+- [@article@Correlation coefficient and correlation test in R](https://statsandr.com/blog/correlation-coefficient-and-correlation-test-in-r/)
+- [@article@Correlation and Regression Analysis in R](https://bookdown.org/siju_swamy/Stat_Lab/correlation-and-regression-analysis-in-r.html)
+- [@video@Correlation Analysis in R](https://www.youtube.com/watch?v=1Yyp8nbMX1k)
+- [@video@How to use ggplot to create beautiful scatter plots.](https://www.youtube.com/watch?v=Dh7P5ExsYCg)

roadmaps/r-programming/content/renv@6dJaQRj2zMz00sfTiTdww.md

@@ -0,0 +1,9 @@
+# renv
+
+renv manages package versions on a per-project basis instead of one shared library for your whole machine. It records the exact package versions a project uses in a lockfile, so anyone who opens that project later can restore the exact same environment. This solves the common problem where a script that worked months ago breaks because a package updated in a way that changed its behavior.
+
+Visit the following resources to learn more:
+
+- [@official@renv](https://cran.r-project.org/web/packages/renv/index.html)
+- [@article@Introduction to renv](https://rstudio.github.io/renv/articles/renv.html)
+- [@video@renv: How to create a stable environment and manage dependencies in R](https://www.youtube.com/watch?v=FWhjQrRZwRg)

roadmaps/r-programming/content/reshaping@cRgcpjX7GlMB_l3ARU1z4.md

@@ -0,0 +1,9 @@
+# Reshaping
+
+Reshaping changes the layout of a dataset without changing its underlying content, most commonly converting between wide and long formats. Wide format spreads related values across separate columns, while long format stacks them into fewer columns with an extra column identifying what each value represents. Many statistical functions and plotting tools expect one shape or the other, so reshaping is often a necessary step before analysis.
+
+Visit the following resources to learn more:
+
+- [@article@Data Reshaping in R Tutorial](https://www.datacamp.com/tutorial/data-reshaping-in-r)
+- [@article@R Data Reshaping](https://data-flair.training/blogs/r-data-reshaping-function-package/)
+- [@video@Reshaping the Data in R](https://www.youtube.com/watch?v=Dc5MtA3Yej0)

roadmaps/r-programming/content/rstatix@-9C077yNLTXLbEo0TW1zU.md

@@ -0,0 +1,7 @@
+# rstatix
+
+rstatix provides a tidyverse-friendly interface for common statistical tests, wrapping base R functions like `t.test()` and `aov()` in a syntax that fits naturally into a dplyr pipeline. It returns results as tidy data frames rather than the more complex object types base R statistical functions typically produce, making the output easier to filter, combine, or feed into a plot. It's a popular choice for anyone who wants classical statistical tests without leaving the tidyverse workflow.
+
+Visit the following resources to learn more:
+
+- [@article@rstatix guide](https://kassambara.r-universe.dev/rstatix)

roadmaps/r-programming/content/rstudio@c8uLNJMr6UZfvjFwFhxvd.md

@@ -0,0 +1,10 @@
+# RStudio
+
+RStudio is the most established integrated development environment for R, combining a script editor, console, plot viewer, and package tools in one window. It has deep, mature support for building R packages and rendering Quarto or R Markdown documents. Posit develops and maintains it, and much existing R documentation still assumes you're working in it.
+
+Visit the following resources to learn more:
+
+- [@official@RStudio IDE](https://posit.co/downloads)
+- [@official@Installing R and RStudio](https://rstudio-education.github.io/hopr/starting.html)
+- [@video@RStudio for beginners](https://www.youtube.com/watch?v=Kgwfuycn9_I)
+- [@video@RStudio for the Total Beginner](https://www.youtube.com/watch?v=FIrsOBy5k58)

roadmaps/r-programming/content/sampling@U6vkyRtFatEi8oCm0zoIK.md

@@ -0,0 +1,9 @@
+# Sampling
+
+Sampling covers the different methods for selecting a subset of a population to study, when studying the entire population isn't feasible, including simple random, stratified, and cluster sampling. It also covers the mechanics of random number generation in R and setting a seed for reproducibility. The right sampling method depends on the structure of the population and what you need the sample to represent.
+
+Visit the following resources to learn more:
+
+- [@article@Sampling in R](https://ds4world.cs.miami.edu/sampling)
+- [@article@Unleashing the Power of Sampling in R: Exploring the Versatile sample() Function](https://www.r-bloggers.com/2023/06/unleashing-the-power-of-sampling-in-r-exploring-the-versatile-sample-function/)
+- [@video@How To... Select Random Samples in R #83](https://www.youtube.com/watch?v=JC3H6eU2jSw)

roadmaps/r-programming/content/scopes@JWRELdQozts-p0448ILYf.md

@@ -0,0 +1,9 @@
+# Scopes
+
+Scoping determines which variables a function can see and use while it runs. R uses lexical scoping, meaning a function looks first inside itself, then in the environment where it was defined, not the environment where it was called from. Understanding scoping becomes especially important once you write nested functions or functions that return other functions.
+
+Visit the following resources to learn more:
+
+- [@article@Scoping Rules of R](https://bookdown.org/rdpeng/rprogdatascience/scoping-rules-of-r.html)
+- [@article@Lexical scoping](https://adv-r.hadley.nz/functions.html)
+- [@video@R Scoping Rules](https://www.youtube.com/watch?v=Xom1XXqiwV0)

roadmaps/r-programming/content/setting-up@6br2AmC31MvGURDUgNtl2.md

@@ -0,0 +1,3 @@
+# Setting Up
+ 
+Setting up R involves configuring the tools around the language itself: managing packages, choosing an IDE, and preparing ways to publish finished work. It's the practical groundwork that makes everyday R work smooth.

roadmaps/r-programming/content/sf@XP4ngNk1Fqzb2nxtHs3Ot.md

@@ -0,0 +1,9 @@
+# sf
+
+sf handles vector spatial data in R, representing points, lines, and polygons, such as store locations or country boundaries. It's built around simple features, a standard format for representing spatial data used across many GIS tools beyond just R. It's the modern standard for vector geospatial work in R, having replaced the older sp package.
+
+Visit the following resources to learn more:
+
+- [@article@Simple Features for R](https://r-spatial.github.io/sf/)
+- [@article@Plot and manipulate geographic features with sf](https://r-graph-gallery.com/package/sf.html)
+- [@video@Create maps using the sf package in R programming](https://www.youtube.com/watch?v=F0ZRYo4SUb8)