Why Rust is used - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print a message about Rust's safety.

Rust

fn main() {
    println!("Rust is {} and fast.");
}

Drag options to blanks, or click blank then click option'

Aslow

Bsafe

Ccomplicated

Dunstable

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing 'slow' because of unfamiliarity with Rust's speed.

Rust is known for being safe and fast, which helps prevent bugs.

2fill in blank

medium

Complete the code to declare a variable that cannot be changed in Rust.

Rust

fn main() {
    let [1] = 10;
    // This variable cannot be changed
}

Drag options to blanks, or click blank then click option'

Ax

Bvar x

Cmut x

Dconst x

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'mut x' which makes the variable mutable.

In Rust, variables are immutable by default. Just 'let x' means it cannot be changed.

3fill in blank

hard

Fix the error in the Rust code that tries to change an immutable variable.

Rust

fn main() {
    let mut x = 5;
    x = [1];
    println!("x is {}", x);
}

Drag options to blanks, or click blank then click option'

A10

Bx + 1

Cmut x

Dlet x

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to assign 'mut x' or 'let x' inside the function body.

The error is trying to assign a new value to an immutable variable. To fix, declare 'x' as mutable or avoid reassignment. Here, just assigning a value to 'x' is the fix.

4fill in blank

hard

Fill both blanks to create a Rust function that returns the sum of two numbers.

Rust

fn sum(a: i32, b: i32) -> i32 {
    [1] a + b;
}

fn main() {
    let result = sum(5, 7);
    println!("Sum is: {}", [2]);
}

Drag options to blanks, or click blank then click option'

Aa + b

Breturn

Cresult

Da - b

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'a + b' as a statement without 'return' or missing the variable in print.

The function uses 'return' to send back the sum. Then 'result' holds the sum to print.

5fill in blank

hard

Fill all three blanks to create a Rust program that uses a vector and prints its length.

Rust

fn main() {
    let mut numbers = Vec::new();
    numbers.[1](10);
    numbers.[2](20);
    println!("Length is: {}", numbers.[3]());
}

Drag options to blanks, or click blank then click option'

Apush

Bpop

Clen

Dinsert

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pop' which removes elements instead of adding.

'push' adds elements to the vector. 'len' returns the number of elements.

Practice

1. Why do many programmers choose Rust for their projects?

easy

A. Because Rust is mainly used for web design

B. Because Rust helps write fast and reliable programs

C. Because Rust does not support memory safety

D. Because Rust is only for beginners

Solution

1. Step 1: Understand Rust's main benefits

   Rust is known for speed and reliability in programming.

2. Step 2: Compare options with Rust's features

   Only Because Rust helps write fast and reliable programs correctly states Rust helps write fast and reliable programs.

3. Final Answer:

   Because Rust helps write fast and reliable programs -> Option B

4. Quick Check:

   Rust = fast and reliable [OK]

Hint: Remember Rust focuses on speed and safety [OK]

Common Mistakes:

• Thinking Rust is only for web design
• Believing Rust ignores memory safety
• Assuming Rust is just for beginners

2. Which of the following is the correct way to describe Rust's memory management?

easy

A. Rust uses garbage collection to manage memory automatically

B. Rust requires manual memory management like C

C. Rust does not manage memory at all

D. Rust uses ownership rules to manage memory safely without garbage collection

Solution

1. Step 1: Recall Rust's memory management approach

   Rust uses ownership and borrowing rules to manage memory safely without garbage collection.

2. Step 2: Match options with Rust's method

   Rust uses ownership rules to manage memory safely without garbage collection correctly describes Rust's ownership system; others are incorrect.

3. Final Answer:

   Rust uses ownership rules to manage memory safely without garbage collection -> Option D

4. Quick Check:

   Ownership system = Rust memory management [OK]

Hint: Rust uses ownership, not garbage collection [OK]

Common Mistakes:

• Confusing Rust with languages that use garbage collection
• Thinking Rust requires manual memory freeing
• Believing Rust ignores memory management

3. What will be the output of this Rust code snippet?

fn main() {
    let x = vec![1, 2, 3];
    let y = x;
    println!("{:?}", x);
    println!("{:?}", y);
}

medium

A. Compilation error due to use of moved value

B. [1, 2, 3]

C. [] (empty vector)

D. Runtime error

Solution

1. Step 1: Understand ownership move in Rust

   Assigning x to y moves ownership of the vector from x to y.

2. Step 2: Check usage of x after move

   Using x after move causes a compile-time error because x no longer owns the data.

3. Final Answer:

   Compilation error due to use of moved value -> Option A

4. Quick Check:

   Using moved value = compile error [OK]

Hint: Using moved variable causes compile error [OK]

Common Mistakes:

• Expecting x to still hold the vector after move
• Thinking Rust allows use after move
• Confusing runtime error with compile error

4. Identify the error in this Rust code and how to fix it:

fn main() {
    let s = String::from("hello");
    let r1 = &s;
    let r2 = &mut s;
    println!("{} and {}", r1, r2);
}

medium

A. Missing semicolon after println! macro

B. String::from is incorrect syntax; fix by using str literal

C. Cannot have mutable and immutable references at the same time; fix by removing one reference

D. No error; code runs fine

Solution

1. Step 1: Understand Rust's borrowing rules

   Rust forbids having mutable and immutable references to the same data at the same time.

2. Step 2: Identify the conflict in code

   r1 is immutable reference, r2 is mutable reference; this causes a compile error.

3. Final Answer:

   Cannot have mutable and immutable references at the same time; fix by removing one reference -> Option C

4. Quick Check:

   Mutable + immutable refs = error [OK]

Hint: Mutable and immutable refs cannot coexist [OK]

Common Mistakes:

• Ignoring Rust's borrowing rules
• Thinking String::from is wrong syntax
• Assuming code compiles without error

5. You want to write a Rust program that safely shares read-only access to data across multiple parts of your program without copying. Which Rust feature helps achieve this best?

hard

A. Using the Rc<T> type for shared ownership with immutable references

B. Using global variables without ownership

C. Using unsafe pointers to bypass ownership rules

D. Using multiple mutable references (&mut) to the data

Solution

1. Step 1: Understand the need for shared read-only access

   Multiple parts need to read data without copying or mutating it.

2. Step 2: Identify Rust feature for shared ownership

   Rc<T> allows multiple owners with immutable references safely.

3. Step 3: Eliminate unsafe or incorrect options

   Mutable references cannot be multiple; unsafe pointers bypass safety; globals lack ownership control.

4. Final Answer:

   Using the Rc<T> type for shared ownership with immutable references -> Option A

5. Quick Check:

   Shared ownership = Rc<T> [OK]

Hint: Use Rc<T> for shared read-only ownership [OK]

Common Mistakes:

• Trying multiple mutable references
• Using unsafe pointers unnecessarily
• Relying on global variables without ownership