Running R code in R Programming - Deep Dive

Overview - Running R code

What is it?

Running R code means telling the R program to execute instructions you wrote. These instructions can be simple calculations, data analysis, or creating graphs. When you run code, R reads each line and performs the tasks step-by-step. This lets you see results immediately or save them for later.

Why it matters

Running R code is how you turn your ideas into actions on the computer. Without running code, your instructions would just be words with no effect. It allows you to analyze data, solve problems, and create visualizations that help understand information. If you never ran code, you couldn't use R to do any work or learn from data.

Where it fits

Before running R code, you should know basic R syntax and how to write simple commands. After learning to run code, you can explore writing functions, using packages, and automating tasks. Running code is the first step in using R effectively for data science or statistics.

Mental Model

Core Idea

Running R code is like pressing 'play' on a recipe that tells the computer exactly what steps to follow.

Think of it like...

Imagine you have a recipe for baking a cake. Running R code is like following the recipe step-by-step to bake the cake and see the final result.

┌───────────────┐
│ Write R code  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Run the code  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ See the result│
└───────────────┘

Build-Up - 7 Steps

1

Foundation

How to run a single R command

Concept: Learn the simplest way to run one line of R code and see its output.

Open R or RStudio. Type a simple command like 2 + 2 and press Enter. R will calculate and show the answer immediately.

Result

[1] 4

Understanding that each line you type can be run immediately helps you test ideas quickly and learn interactively.

2

Foundation

Running multiple lines of code

Concept: Learn how to run several lines of R code together to perform more complex tasks.

Write multiple lines of code in a script file or console. For example: x <- 5 y <- 10 x + y Run all lines to see the final result.

Result

[1] 15

Knowing how to run multiple lines lets you build step-by-step solutions and reuse code easily.

3

Intermediate

Using R scripts and source function

🤔Before reading on: do you think running code from a script file is the same as typing it line-by-line? Commit to your answer.

Concept: Learn how to save code in a file and run it all at once using the source() function.

Save your R commands in a file named 'script.R'. Then in R, run source('script.R') to execute all commands inside the file at once.

Result

All commands in script.R run and their results appear in the console.

Understanding how to run scripts helps organize your work and repeat analyses without retyping code.

4

Intermediate

Running code interactively in RStudio

🤔Before reading on: do you think running code in RStudio is different from running it in R console? Commit to your answer.

Concept: Learn how RStudio lets you run code line-by-line or in chunks interactively with shortcuts.

In RStudio, write code in the script editor. Use Ctrl+Enter (Cmd+Enter on Mac) to run the current line or selection. Results show in the console immediately.

Result

Selected code runs and output appears below.

Interactive running speeds up testing and debugging by letting you try small parts of code quickly.

5

Intermediate

Running code with R Markdown

Concept: Learn how to run R code inside documents that combine text and code for reports.

Create an R Markdown file (.Rmd). Write text and R code chunks inside. When you knit the document, R runs the code and inserts results into the report.

Result

A report with text and code output combined.

Running code inside documents helps create reproducible reports that explain your analysis clearly.

6

Advanced

Running R code in batch mode

🤔Before reading on: do you think batch mode runs code the same way as interactive mode? Commit to your answer.

Concept: Learn how to run R scripts without opening R interactively, useful for automation.

Use the command line: Rscript script.R or R CMD BATCH script.R to run code in batch mode. This runs the script and saves output to a file.

Result

Script runs without user interaction; output saved to file.

Knowing batch mode lets you automate tasks and run analyses on servers or schedules without manual input.

7

Expert

How R evaluates code internally

🤔Before reading on: do you think R runs code line-by-line exactly as written, or does it do extra steps? Commit to your answer.

Concept: Understand the internal process R uses to parse, evaluate, and return results from code.

R first parses code into expressions, then evaluates each in an environment. It handles lazy evaluation, meaning it only computes values when needed. This allows flexible programming and efficient execution.

Result

Code runs with delayed evaluation and environment scoping.

Understanding R's evaluation model explains why some code behaves unexpectedly and helps write more efficient and correct programs.

Under the Hood

When you run R code, the interpreter first reads your text and breaks it into expressions. Each expression is then evaluated in an environment that holds variables and functions. R uses lazy evaluation, so it delays computing values until absolutely necessary. The results are then printed or stored. This process allows R to be flexible and interactive.

Why designed this way?

R was designed for statisticians who want to explore data interactively. Lazy evaluation and environments let users write code that is easy to modify and extend. This design balances ease of use with powerful programming features, unlike older languages that require strict order or manual memory management.

┌───────────────┐
│ User writes   │
│ R code text   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Parser breaks │
│ code into     │
│ expressions   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Evaluator runs│
│ expressions   │
│ in environment│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Results shown │
│ or stored     │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does running code in R always show output automatically? Commit to yes or no.

Common Belief: Running any R code line always shows the result immediately.

Reality: Some commands, like assignments (x <- 5), do not print output unless explicitly asked.

Why it matters: Expecting output when none appears can confuse beginners and hide errors.

Quick: Do you think running code in a script file is exactly the same as typing it in the console? Commit to yes or no.

Common Belief: Running code from a script file is identical to typing it line-by-line in the console.

Reality: Scripts run all at once and may behave differently due to environment or order, unlike interactive typing.

Why it matters: Not knowing this can cause unexpected bugs when moving from console experiments to scripts.

Quick: Does R run code in batch mode interactively? Commit to yes or no.

Common Belief: Batch mode runs code interactively just like the console.

Reality: Batch mode runs code without interaction and saves output to files, no user input possible.

Why it matters: Misunderstanding this can cause confusion when automating tasks or running code on servers.

Quick: Is R's evaluation always immediate and strict? Commit to yes or no.

Common Belief: R evaluates all code immediately and strictly in the order written.

Reality: R uses lazy evaluation, delaying computation until needed, which can affect how code runs.

Why it matters: Ignoring lazy evaluation can lead to subtle bugs and inefficient code.

Expert Zone

1

Running code in RStudio can use different environments, affecting variable visibility and debugging.

2

Lazy evaluation means function arguments are only computed if used, enabling powerful programming patterns.

3

Batch mode output files can include warnings and messages that don't appear in interactive sessions, requiring careful checking.

When NOT to use

Running code interactively is not suitable for large automated workflows or scheduled tasks; use batch mode or Rscript instead. For reproducible reports, prefer R Markdown over manual console runs.

Production Patterns

Professionals use scripts with source() for automation, R Markdown for reports, and batch mode for scheduled jobs. Interactive running is mainly for exploration and debugging.

Connections

Shell scripting

Both run code line-by-line or in batch to automate tasks.

Understanding running R code helps grasp how shell scripts execute commands, enabling automation across systems.

Cooking recipes

Running code is like following a recipe step-by-step to get a final dish.

This connection helps appreciate the importance of order and completeness in instructions for successful outcomes.

Human learning process

Running code interactively mimics trial-and-error learning with immediate feedback.

Recognizing this helps design better learning environments and debugging strategies.

Common Pitfalls

#1 Expecting output from assignment statements.

Wrong approach:

x <- 10
# No output shown

Correct approach:

x <- 10
print(x)
# Output: [1] 10

Root cause:

Beginners think all code lines print results automatically, but assignments do not.

#2 Running script without setting working directory.

Wrong approach:

source('data_analysis.R')
# Error: file not found

Correct approach:

setwd('path/to/script')
source('data_analysis.R')
# Script runs successfully

Root cause:

Not understanding that R looks for files relative to the current working directory.

#3 Using interactive commands in batch mode expecting prompts.

Wrong approach:

readline('Enter value: ')
# Batch mode hangs or fails

Correct approach:

# Avoid interactive input in batch mode; use command line arguments instead

Root cause:

Misunderstanding that batch mode cannot handle user input during execution.

Key Takeaways

Running R code is the essential step to make your instructions do work on the computer.

You can run single lines, multiple lines, or entire scripts depending on your needs.

Interactive running is great for learning and testing, while batch mode suits automation.

R's internal lazy evaluation and environment model affect how and when code runs.

Knowing how to run code properly helps avoid common mistakes and makes your work reproducible.