First R program in R Programming - Deep Dive

Overview - First R program

What is it?

An R program is a set of instructions written in the R language that a computer can run to perform tasks. The first R program usually means writing a simple script that prints a message or does a basic calculation. R is a language mainly used for statistics and data analysis, but it can also do general programming tasks. Writing your first R program helps you start communicating with the computer using R.

Why it matters

Without knowing how to write your first R program, you cannot use R to analyze data or solve problems. This first step opens the door to exploring data, making graphs, and running calculations automatically. Without it, you would have to do everything by hand, which is slow and error-prone. Learning this first program builds confidence and shows how computers can help with real-world tasks.

Where it fits

Before this, you should know what a computer program is and have basic computer skills like opening software and typing. After learning your first R program, you will move on to understanding variables, data types, and how to write more complex instructions in R.

Mental Model

Core Idea

Writing your first R program is like giving the computer a simple recipe to follow step-by-step.

Think of it like...

It's like telling a friend exactly what to say or do, one instruction at a time, so they can help you without guessing.

┌─────────────────────────────┐
│ Start R program             │
├─────────────────────────────┤
│ 1. Write instruction        │
│ 2. Run instruction          │
│ 3. See output on screen     │
└─────────────────────────────┘

Build-Up - 6 Steps

1

Foundation

Opening R and the Console

Concept: Learn how to start R and find where to type commands.

To write your first R program, first open the R software or RStudio. You will see a console where you can type commands. This console is like a chat window where you talk to the computer. Try typing simple math like 2 + 2 and press Enter to see the result.

Result

[1] 4

Knowing where and how to type commands is the first step to controlling the computer with R.

2

Foundation

Printing Text with print()

Concept: Use the print() function to show messages on the screen.

In R, you can show messages using the print() function. For example, type print("Hello, world!") and press Enter. The computer will display the message inside the quotes.

Result

[1] "Hello, world!"

Understanding how to display output helps you check what your program is doing.

3

Intermediate

Saving Code in a Script File

🤔Before reading on: Do you think typing commands in the console and saving them in a script file are the same? Commit to your answer.

Concept: Learn to write multiple commands in a file to run them all at once.

Instead of typing commands one by one in the console, you can write them in a script file. In RStudio, create a new script, type your commands like print("Hello") and 2 + 2, then save the file with .R extension. You can run the whole script to see all results together.

Result

[1] "Hello" [1] 4

Knowing how to save and run scripts lets you build programs that do more than one thing.

4

Intermediate

Using Comments to Explain Code

🤔Before reading on: Do you think comments affect how the program runs? Commit to your answer.

Concept: Add notes in your code that the computer ignores but help humans understand.

In R, anything after a # sign is a comment. For example, # This prints a message. Comments do not run but explain what the code does. Use comments to remind yourself or others why you wrote certain commands.

Result

No output from comments, but code is easier to read.

Using comments improves code clarity and helps avoid confusion later.

5

Advanced

Running Scripts from the Command Line

🤔Before reading on: Can you run an R script without opening RStudio? Commit to your answer.

Concept: Learn to run R programs from outside the R software using the command line.

You can run an R script file from your computer's terminal or command prompt by typing Rscript yourfile.R. This runs the program and shows output in the terminal. This is useful for automating tasks or running programs on servers.

Result

Output of the script appears in the terminal window.

Knowing how to run scripts outside RStudio expands where and how you can use R programs.

6

Expert

Understanding R's Execution Model

🤔Before reading on: Do you think R runs all code at once or line by line? Commit to your answer.

Concept: Learn how R processes commands one at a time and how this affects program behavior.

R reads and executes code line by line in the order written. Each command runs immediately and can change the environment, like creating variables or printing output. This means the order of commands matters a lot. Also, R keeps track of objects in memory while running your program.

Result

Commands run sequentially, and output appears after each command.

Understanding R's step-by-step execution helps avoid bugs and write predictable programs.

Under the Hood

When you run an R program, the R interpreter reads each line of code from top to bottom. It converts the text into instructions the computer understands and executes them immediately. For print() commands, it sends the text to the console output. Variables and functions are stored in memory so they can be used later. This process is called interpretation, different from compiling where code is translated all at once before running.

Why designed this way?

R was designed as an interactive language for statisticians to quickly test ideas and see results. Interpreted execution allows immediate feedback, which is great for learning and data exploration. Compiling would slow down this process and make it harder to experiment. This design choice favors ease of use over raw speed.

┌───────────────┐
│ R Program     │
│ (Script file) │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ R Interpreter │
│ Reads line 1  │
│ Executes line │
│ Stores data   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Console Output│
│ Shows results │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does typing print("Hello") and Hello without print() show the same output? Commit to yes or no.

Common Belief: Typing text without print() will display it on the screen just like print() does.

Reality: Only print() or similar functions display text explicitly; typing text alone without quotes or print() causes errors or no output.

Why it matters: Assuming text shows without print() leads to confusion and errors when programs don't display expected messages.

Quick: Can you run multiple commands in the console exactly like in a script file? Commit to yes or no.

Common Belief: Typing commands one by one in the console is the same as running a saved script file.

Reality: Console commands run immediately and separately, while scripts run all commands in order, which can affect program state and output.

Why it matters: Not understanding this difference can cause unexpected results when moving from console testing to script execution.

Quick: Does R compile your program before running it? Commit to yes or no.

Common Belief: R compiles the entire program before running it, like some other languages do.

Reality: R interprets and runs code line by line without compiling it first.

Why it matters: Expecting compilation can lead to confusion about errors and program speed.

Quick: If you forget to save your script, will your program still run later? Commit to yes or no.

Common Belief: Once typed, your code is saved automatically and can be run anytime later without saving.

Reality: If you don't save your script file, the code is lost when you close the editor and cannot be run again.

Why it matters: Losing unsaved work wastes time and causes frustration.

Expert Zone

1

R's interactive nature means that objects created in the console persist until removed, which can cause hidden bugs if old variables interfere with new code.

2

Scripts can be sourced multiple times, but side effects like file writes or random number generation may produce different results each run unless controlled.

3

The print() function is not always needed; R automatically prints the result of expressions in the console, but this behavior differs in scripts and functions.

When NOT to use

For very large or performance-critical applications, R's interpreted scripts may be too slow; compiled languages like C++ or specialized tools like Rcpp should be used instead.

Production Patterns

In production, R scripts are often scheduled to run automatically using tools like cron jobs or integrated into pipelines with R Markdown or Shiny apps to deliver reports and dashboards.

Connections

Shell scripting

Both involve writing text files with commands to automate tasks.

Understanding how scripts run in R helps grasp how shell scripts automate system tasks, showing a shared pattern of instruction sequences.

Recipe writing

Both give step-by-step instructions to achieve a goal.

Knowing that programming is like writing recipes helps understand the importance of order and clarity in instructions.

Human language learning

Learning to write your first program is like learning to speak a new language with its own rules and vocabulary.

Recognizing programming as language acquisition highlights the need for practice, patience, and gradual complexity.

Common Pitfalls

#1 Typing text without quotes or print() expecting output.

Wrong approach:

Hello, world!

Correct approach:

print("Hello, world!")

Root cause:

Not knowing that R requires quotes for text and print() to display it.

#2 Running code only in console and not saving it.

Wrong approach:

Typing commands in console and closing R without saving.

Correct approach:

Writing commands in a script file and saving it with .R extension.

Root cause:

Not understanding the difference between temporary console commands and saved scripts.

#3 Expecting R to run all code at once like compiled languages.

Wrong approach:

Writing code assuming all errors will be caught before running.

Correct approach:

Running code line by line and fixing errors as they appear.

Root cause:

Misunderstanding R's interpreted execution model.

Key Takeaways

Your first R program is a simple set of instructions that the computer runs one by one.

Using print() shows messages on the screen, helping you see what your program does.

Saving code in script files lets you run multiple commands together and reuse your work.

R runs code line by line without compiling, so the order of commands matters a lot.

Comments help explain your code but do not affect how it runs.