Writing first Rust program - Step-by-Step Execution

Concept Flow - Writing first Rust program

Start program

↓

Call main function

↓

Execute println! macro

↓

Print message to screen

↓

End program

The program starts by calling the main function, which runs the println! macro to print a message, then ends.

Execution Sample

Rust

fn main() {
    println!("Hello, world!");
}

This program prints the message "Hello, world!" to the screen.

Execution Table

Step	Action	Evaluation	Result
1	Start program	Program begins	Ready to run main()
2	Call main function	Enter main()	Inside main()
3	Execute println! macro	Print string	Displays: Hello, world!
4	End main function	main() finishes	Program ends

💡 Program ends after main() finishes running

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
No variables	N/A	N/A	N/A	N/A

Key Moments - 2 Insights

Why do we use println! instead of a normal function?

println! is a macro in Rust that prints text to the screen. It looks like a function but adds extra features like formatting. See step 3 in the execution table where println! prints the message.

What does fn main() mean?

fn main() defines the main function, which is the starting point of every Rust program. Step 2 shows the program entering main() to run the code inside.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 3?

A The main function is called

B The program ends

C The program prints 'Hello, world!' to the screen

D The program starts

💡 Hint

Check the 'Result' column at step 3 in the execution table

At which step does the program finish running?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look at the 'Action' and 'Result' columns to find when main() ends

If we change the message inside println! to "Hi!", what changes in the execution table?

A The 'Result' at step 3 changes to display 'Hi!'

B Step 2 will change

C The program will end earlier

D No changes at all

💡 Hint

Focus on the 'Result' column at step 3 where the printed message appears

Concept Snapshot

fn main() { ... } defines the program start.
Use println!("text") to print messages.
Program runs main(), executes println!, then ends.
println! is a macro for printing.
No variables needed for this simple program.

Full Transcript

This Rust program starts by running the main function. Inside main, the println! macro prints the message 'Hello, world!' to the screen. After printing, the program ends. The println! macro is special because it formats and prints text. The main function is the required entry point for Rust programs. There are no variables in this simple example. The execution table shows each step clearly: starting the program, entering main, printing the message, and ending the program.

Practice

1. What is the correct way to start a basic Rust program?

easy

A. By defining a fn main() function

B. By writing start() function

C. By using begin() function

D. By declaring a program() function

Solution

1. Step 1: Understand Rust program entry point

   Rust programs always start execution from the main function.

2. Step 2: Identify the correct function name

   The correct function to start a Rust program is fn main().

3. Final Answer:

   By defining a fn main() function -> Option A

4. Quick Check:

   Rust program entry point = fn main() [OK]

Hint: Rust programs always start with fn main() [OK]

Common Mistakes:

• Using incorrect function names like start() or begin()
• Omitting the main function entirely
• Confusing Rust with other languages' entry points

2. Which of the following is the correct syntax to print "Hello, world!" in Rust?

easy

A. print!("Hello, world!");

B. println!("Hello, world!");

C. echo("Hello, world!");

D. console.log("Hello, world!");

Solution

1. Step 1: Identify Rust's print macro

   Rust uses the macro println! to print text with a newline.

2. Step 2: Compare options

   Only println!("Hello, world!"); is valid Rust syntax for printing with a newline.

3. Final Answer:

   println!("Hello, world!"); -> Option B

4. Quick Check:

   Print with newline = println! macro [OK]

Hint: Use println! to print with a newline in Rust [OK]

Common Mistakes:

• Using print! without newline when newline is expected
• Using functions from other languages like echo or console.log
• Missing the exclamation mark after println

3. What will be the output of this Rust program?

fn main() {
    println!("{}", 5 + 3);
}

medium

A. 8

B. 5 + 3

C. {}

D. Compilation error

Solution

1. Step 1: Understand the println! macro with placeholders

   The {} inside the string is a placeholder for the value following the string.

2. Step 2: Calculate the expression inside println!

   The expression 5 + 3 evaluates to 8, which replaces the {}.

3. Final Answer:

   8 -> Option A

4. Quick Check:

   5 + 3 = 8 printed [OK]

Hint: {} prints evaluated expression inside println! [OK]

Common Mistakes:

• Expecting the literal string '5 + 3' to print
• Confusing {} as a string literal
• Thinking it causes a compile error

4. Identify the error in this Rust program:

fn main() {
    println!("Hello, world!")
}

medium

A. Missing quotation marks around string

B. Incorrect function name main

C. Missing semicolon after println! macro

D. println! macro does not exist

Solution

1. Step 1: Check syntax of println! macro call

   In Rust, statements must end with a semicolon unless they are the last expression in a block.

2. Step 2: Identify missing semicolon

   The println!("Hello, world!") line is missing a semicolon at the end.

3. Final Answer:

   Missing semicolon after println! macro -> Option C

4. Quick Check:

   Statements need semicolon unless last expression [OK]

Hint: Add semicolon after println! unless last expression [OK]

Common Mistakes:

• Forgetting semicolon after macro calls
• Thinking main function name is wrong
• Assuming println! is not a macro

5. You want to write a Rust program that prints "Hello, <name>!" where <name> is a variable. Which code correctly does this?

hard

A. fn main() {
let name = "Alice";
println!("Hello, {name}!");
}

B. fn main() {
let name = "Alice";
println!("Hello, name!");
}

C. fn main() {
let name = "Alice";
print!("Hello, {}!", name);
}

D. fn main() {
let name = "Alice";
println!("Hello, {}!", name);
}

Solution

1. Step 1: Understand variable interpolation in println!

   Rust uses {} as a placeholder and variables are passed after the string.

2. Step 2: Check each option for correct syntax and output

   fn main() { let name = "Alice"; println!("Hello, {}!", name); } correctly uses println!("Hello, {}!", name); to print the variable's value.

3. Final Answer:

   fn main() { let name = "Alice"; println!("Hello, {}!", name); } -> Option D

4. Quick Check:

   Use {} and pass variable to println! [OK]

Hint: Use {} and pass variable to println! for interpolation [OK]

Common Mistakes:

• Putting variable name inside quotes without {}
• Using print! instead of println! (missing newline)
• Trying to use {name} without Rust 1.58+ raw identifiers