IS4010: AI-Enhanced Application Development

Week 11: Structuring Code and Data in Rust

Brandon M. Greenwell

Session 1: Organizing Code and Custom Types

This week builds directly on ownership fundamentals from Week 10. Students now know how memory works in Rust - today they learn how to structure programs and data. Start with motivation: “You can write Rust code - now let’s organize it like professionals do.”

From small scripts to real programs

• So far, we’ve written small Rust programs in a single main.rs file
• Real applications need organization: separate files, logical grouping, reusable components
• Rust’s module system provides powerful tools for structuring code
• Today we learn how professionals organize Rust projects

Transition from “can you write Rust?” to “can you organize Rust?” Students have the fundamentals - now we scale up to real programs. The module system is Rust’s answer to organization.

The Rust module system hierarchy

Three levels of organization:

1. Packages - A Cargo feature that builds, tests, and shares crates
2. Crates - A tree of modules that produces a library or executable
3. Modules - Let you control organization, scope, and privacy

Think of it like: Package = project, Crate = building, Modules = rooms

The hierarchy confuses newcomers. Use the building analogy: package is the whole project, crate is a library or binary, modules are logical divisions. We’ll focus on modules today since that’s what students will use most.

Creating modules with mod

// src/main.rs

mod math {  // Define a module named 'math'

    pub fn add(a: i32, b: i32) -> i32 {  // 'pub' makes this visible outside the module
        a + b  // Return the sum
    }

    fn subtract(a: i32, b: i32) -> i32 {  // No 'pub' = private to this module only
        a - b  // Return the difference
    }
}

fn main() {
    println!("2 + 3 = {}", math::add(2, 3));  // ✅ Works! add() is public
    // println!("5 - 2 = {}", math::subtract(5, 2));  // ❌ ERROR: subtract() is private!
}

Try it in Rust Playground

Show module definition with mod. Explain pub keyword - everything is private by default. Show the path syntax with ::. Have students try calling math::subtract() in the Playground to see the error. Then have them change subtract to pub and see it work. This simple example teaches the core concept clearly.

Privacy in Rust: default private

• Everything is private by default in Rust modules
• Use pub keyword to make items public
• Privacy rules:
  • Parent modules can’t see into child private items
  • Child modules can see everything in parent modules
  • Sibling modules can see each other’s public items
• This is defensive design - explicit about your public API

Contrast with Python where everything is public by convention. Rust enforces privacy at compile time. This prevents accidental dependencies on internal implementation details. It’s about intentional design.

Quick rule of thumb: when do you need pub? 🤔

✅ Use pub when accessed from:

• A parent module
• A sibling’s child module
• Outside the crate

Example: Public API functions, structs used by other modules

❌ No pub needed when accessed from:

• The same module
• Its child modules

Example: Helper functions, internal implementation details

This is the practical guidance students need. Most confusion comes from not understanding the scope. Key insight: child modules have access to parent’s private items (unusual compared to other languages), but parents don’t have access to children’s private items (this is normal). When in doubt, try compiling without pub first - the compiler will tell you if you need it!

Example: pub visibility in action

mod calculator {  // Parent module

    fn validate_inputs(a: i32, b: i32) -> bool {  // ❌ No pub - internal helper only
        b != 0  // Make sure we're not dividing by zero
    }

    pub mod operations {  // ✅ pub - main() needs to access this module

        pub fn divide(a: i32, b: i32) -> i32 {  // ✅ pub - public API function
            if super::validate_inputs(a, b) {  // ✅ Child can access parent's private!
                a / b  // Do the division
            } else {
                0  // Return 0 for invalid inputs (simplified error handling)
            }
        }

        fn log_operation(msg: &str) {  // ❌ Private - internal to operations only
            println!("LOG: {}", msg);  // Internal logging
        }
    }
}

fn main() {
    println!("10 / 2 = {}", calculator::operations::divide(10, 2));  // ✅ Works! Both pub
    // calculator::validate_inputs(10, 2);  // ❌ Error! validate_inputs is private
    // calculator::operations::log_operation("test");  // ❌ Error! log_operation is private
}

Try it in Rust Playground

Show this code working in the Playground. Then have students uncomment the error lines one at a time to see the errors. Key point: divide() is in a CHILD module (operations) but can call parent’s validate_inputs() with super::. This asymmetry confuses students - child can see parent’s private, but parent can’t see child’s private. Spend time on this concept. The example is deliberately simple (returning 0 for errors) to focus on the visibility rules, not error handling.

The use keyword: bringing paths into scope

mod math {  // Parent module

    pub mod operations {  // Public submodule
        pub fn add(a: i32, b: i32) -> i32 {  // Public function
            a + b  // Return the sum
        }

        pub fn multiply(a: i32, b: i32) -> i32 {  // Public function
            a * b  // Return the product
        }
    }
}

// Bring the operations module into scope with 'use'
use math::operations;

fn main() {
    println!("2 + 3 = {}", operations::add(2, 3));  // ✅ Shorter! Just operations::add
    println!("2 * 3 = {}", operations::multiply(2, 3));  // Instead of math::operations::multiply
    // Without 'use', we'd need: math::operations::add(2, 3)
}

Try it in Rust Playground

‘use’ is like Python’s import or Java’s import. It creates shortcuts. Note the idiomatic pattern: bring the parent module into scope (operations), not the function itself. This makes it clear where functions come from. Have students try ‘use math::operations::add;’ to see the difference - it’s less clear and goes against Rust conventions.

Separating modules into files

Project structure:

src/
├── main.rs
├── math.rs
└── math/
    ├── operations.rs
    └── constants.rs

In main.rs:

mod math;  // Tells Rust to look for math.rs (no braces = load from file)

use math::operations;  // Import the operations submodule

fn main() {
    println!("{}", operations::add(2, 3));  // Use the add function
}

In math.rs:

// src/math.rs
// This file declares what submodules exist under 'math'
pub mod operations;  // Makes operations public and tells Rust to load math/operations.rs
pub mod constants;   // Makes constants public and tells Rust to load math/constants.rs

In math/operations.rs:

// src/math/operations.rs
// This file contains the actual implementation of math operations
pub fn add(a: i32, b: i32) -> i32 {  // Public function
    a + b  // Return sum
}

pub fn multiply(a: i32, b: i32) -> i32 {  // Public function
    a * b  // Return product
}

In math/constants.rs:

// src/math/constants.rs
// This file defines mathematical constants
pub const PI: f64 = 3.14159;  // Approximation of pi
pub const E: f64 = 2.71828;   // Approximation of Euler's number

Real projects split modules into separate files. The ‘mod’ declaration without braces tells Rust to load from a file. This is how professional Rust code is organized. The file system mirrors the module tree. The math.rs file declares the submodules (operations and constants). Students can try this in VS Code - create these files and run cargo build to see it work.

🤖 AI co-pilot technique: module organization

When organizing code into modules, ask your AI assistant:

Effective prompts: - “How should I organize this Rust project into modules? [describe project]” - “What should be public vs private in this module? [paste code]” - “Explain the difference between ‘use’ and ‘mod’ in Rust” - “Help me split this large main.rs into separate modules”

Pro tip: Ask AI to explain the module tree structure - visualizations help!

Module organization is a design skill. AI can suggest logical groupings and explain privacy trade-offs. Students should use AI to learn patterns, not just copy structure. Understanding module design makes code maintainable.

Defining custom data with struct

• A struct (structure) groups related data into a single, meaningful type
• Like Python classes but data only (methods come separately)
• Three kinds:
  1. Named-field structs - most common
  2. Tuple structs - fields accessed by position
  3. Unit structs - no fields (rare)

struct User {
    username: String,
    email: String,
    active: bool,
    sign_in_count: u64,
}

Structs are how you model domain concepts in Rust. Coming from Python, think of them as the data part of a class. The separation of data and behavior is intentional - Rust favors composition.

Creating struct instances

struct User {
    username: String,
    email: String,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("ada@example.com"),
        username: String::from("ada_lovelace"),
        active: true,
    };

    println!("Username: {}", user1.username);

    // Make mutable to change fields
    let mut user2 = User {
        email: String::from("grace@example.com"),
        username: String::from("grace_hopper"),
        active: true,
    };
    user2.email = String::from("new_email@example.com");
}

Try it in Rust Playground

LIVE DEMO: Create a struct instance. Show that the entire struct must be mutable to change any field - Rust doesn’t have per-field mutability. This is consistent with Rust’s ownership model.

Adding behavior with impl blocks

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // Method (takes &self)
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // Associated function (no self) - like a static method
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let rect = Rectangle { width: 30, height: 50 };
    println!("Area: {}", rect.area());

    let sq = Rectangle::square(10);
}

Try it in Rust Playground

impl blocks add methods to structs. Methods take self (or &self or &mut self). Associated functions don’t take self - they’re like constructors or static methods. You can have multiple impl blocks for organization.

Modeling choices with enum

• An enum (enumeration) represents a value that can be one of several variants
• Much more powerful than enums in C, Java, or Python
• Each variant can hold different types of data
• Perfect for modeling “this OR that OR that” situations

enum Shape {  // Define an enum to represent different geometric shapes
    Circle(f64),              // Circle variant holds radius
    Rectangle(f64, f64),      // Rectangle holds width and height
    Triangle(f64, f64),       // Triangle holds base and height
}

// Create instances of different shapes
let circle = Shape::Circle(5.0);                    // Circle with radius 5.0
let rectangle = Shape::Rectangle(4.0, 6.0);         // Rectangle 4.0 × 6.0
let triangle = Shape::Triangle(3.0, 8.0);           // Triangle with base 3.0, height 8.0

Try it in Rust Playground

Rust enums are algebraic data types - incredibly powerful! Each variant can hold different amounts and types of data. Circle needs one dimension (radius), Rectangle needs two (width, height), Triangle needs two (base, height). This is the perfect use case for enums - same concept (shape) but different data structure. This is much more powerful than C-style enums which are just named integers.

Computer science terminology: Rust enums are “sum types” or “tagged unions” from functional programming. They encode different states and their associated data within a single type, which the compiler checks exhaustively. The Shape example clearly shows this - each variant is mutually exclusive (a shape is a circle OR rectangle OR triangle, never multiple at once).

Pattern matching with match

enum Shape {  // Define different geometric shapes
    Circle(f64),              // Circle holds radius
    Rectangle(f64, f64),      // Rectangle holds width and height
    Triangle(f64, f64),       // Triangle holds base and height
}

fn area(shape: Shape) -> f64 {  // Calculate area for any shape
    match shape {  // Pattern match on the shape variant
        Shape::Circle(r) => {  // Extract radius from Circle
            println!("Calculating area of circle with radius {}", r);
            3.14159 * r * r  // Formula: πr²
        }
        Shape::Rectangle(w, h) => {  // Extract width and height
            w * h  // Formula: width × height
        }
        Shape::Triangle(b, h) => {  // Extract base and height
            0.5 * b * h  // Formula: ½ × base × height
        }
    }  // ✅ Compiler ensures we handle ALL variants!
}

fn main() {
    let circle = Shape::Circle(5.0);  // Create a circle with radius 5.0
    println!("Area: {:.2} square units", area(circle));  // Output: 78.54

    let rect = Shape::Rectangle(4.0, 6.0);  // Create a 4×6 rectangle
    println!("Area: {:.2} square units", area(rect));  // Output: 24.00
}

Try it in Rust Playground

LIVE DEMO: This perfectly shows why match with enums is powerful! Each shape needs a different formula - pattern matching makes this natural and safe. The compiler ensures exhaustiveness - you MUST handle every variant. If you add a new shape later, the compiler will force you to update every match statement. Pattern matching extracts the data (radius, width/height, base/height) so you can use it in calculations. This prevents forgotten cases that cause bugs in other languages. Try removing one match arm to see the compiler error!

🤖 AI co-pilot technique: designing with structs and enums

When modeling data, ask your AI assistant:

Effective prompts: - “Should I use a struct or enum for this? [describe data]” - “Help me model a [domain concept] in Rust with structs and enums” - “What fields should this struct have? [describe requirements]” - “Show me how to use match to handle all cases of this enum”

Example: “I need to model a blog post that can be Draft, Published, or Archived. Each state has different data. How should I structure this in Rust?”

Data modeling is a design skill. AI can suggest struct vs enum trade-offs and show idiomatic patterns. Ask AI to explain the reasoning, not just provide code. Understanding design choices makes better Rust developers.

Session 2: Error Handling and Collections

Second session builds on structs/enums. Now we use two special enums (Option and Result) and work with dynamic collections. Emphasize that these aren’t “advanced” - they’re everyday Rust. Tie to ownership from last week.

The problem with null

• In Python, Java, C++, variables can be None/null
• This causes billions of dollars in bugs: Tony Hoare calls it his “billion-dollar mistake”
• The problem: you can forget to check for null, causing crashes
• Rust’s solution: no null - instead, use Option<T>

Null reference errors are among the most common bugs. Tony Hoare invented null and regrets it. Rust eliminates this entire category of bugs by making “might not exist” explicit in the type system.

Option<T>: handling optional values

enum Option<T> {
    Some(T),
    None,
}

fn find_user(id: u32) -> Option<String> {
    if id == 1 {
        Some(String::from("Alice"))
    } else {
        None
    }
}

fn main() {
    match find_user(1) {
        Some(name) => println!("Found: {}", name),
        None => println!("User not found"),
    }

    // Shorthand with if let
    if let Some(name) = find_user(2) {
        println!("Found: {}", name);
    } else {
        println!("User not found");
    }
}

Try it in Rust Playground

LIVE DEMO: Show Option in action. The type system forces you to handle the None case - you can’t forget. Show both match and if let patterns. if let is syntactic sugar for matching one pattern and ignoring others.

Result<T, E>: recoverable errors

enum Result<T, E> {
    Ok(T),
    Err(E),
}

use std::fs::File;
use std::io::ErrorKind;

fn open_config() -> Result<File, std::io::Error> {
    File::open("config.txt")
}

fn main() {
    match open_config() {
        Ok(file) => println!("Opened file successfully"),
        Err(error) => match error.kind() {
            ErrorKind::NotFound => println!("File not found!"),
            other => println!("Error opening file: {:?}", other),
        },
    }
}

Try it in Rust Playground

Result is for operations that can fail. Like Option, the type system forces you to handle errors. No more forgotten try/catch! You can nest matches to handle specific error types. This is much safer than exceptions.

The ? operator: error propagation

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("username.txt")?; // ❓ propagates error if Err
    let mut username = String::new();
    file.read_to_string(&mut username)?;        // ❓ propagates error if Err
    Ok(username)                                  // ✅ returns Ok if success
}

// Without ? operator, this would be:
// match File::open("username.txt") {
//     Ok(mut file) => match file.read_to_string(&mut username) {
//         Ok(_) => Ok(username),
//         Err(e) => Err(e),
//     },
//     Err(e) => Err(e),
// }

The ? operator is syntactic sugar for error propagation. If Result is Err, it returns early with that error. If Ok, it unwraps the value and continues. This makes error handling code much cleaner. It’s like try/catch but explicit in types.

Important constraint: Remind students that the ? operator can only be used inside a function that returns a Result or an Option. The compiler will give an error if you try to use it in a function like main that doesn’t return one of these types (unless you change main’s return type to Result<(), E>).

🤖 AI co-pilot technique: error handling patterns

When handling errors, ask your AI assistant:

Effective prompts: - “When should I use Option vs Result in Rust?” - “Help me handle this error idiomatically: [paste code]” - “Explain the ? operator and when I can use it” - “Convert this match error handling to use ? operator”

Pro tip: Ask AI to show both verbose (match) and concise (? operator) versions to understand what’s happening under the hood.

Error handling patterns take practice. AI can show idiomatic approaches and explain trade-offs. Students should understand both match and ? operator - ? is sugar for match patterns. Ask AI to explain, not just provide code.

Common collections: Vec<T>

• Vec<T> (vector) is a growable array - like Python’s list
• Stores values of the same type
• Allocated on the heap (flexible size)
• Most common collection in Rust

fn main() {
    // Creating vectors
    let mut v: Vec<i32> = Vec::new();
    let mut v2 = vec![1, 2, 3]; // vec! macro for initial values

    // Adding elements
    v.push(5);
    v.push(6);

    // Accessing elements
    let third = &v2[2];         // Panics if out of bounds
    let maybe_third = v2.get(2); // Returns Option<&T>

    // Iterating
    for i in &v2 {
        println!("{}", i);
    }
}

Try it in Rust Playground

LIVE DEMO: Show Vec creation, push, indexing, and iteration. Explain the two ways to access: [] panics if out of bounds, .get() returns Option. This ties back to Option from earlier. Vectors follow ownership rules - you can’t modify while iterating immutably.

Performance insight: Mention that when a Vec’s capacity is exceeded, it must perform a new allocation on the heap and copy all existing elements over. For performance-critical code, pre-allocating with Vec::with_capacity can be a useful optimization.

Strings in Rust: String vs &str

• Rust has two main string types (not one!):
• String - Owned, growable, heap-allocated (like Vec<u8>)
• &str - String slice, borrowed, immutable view
• All strings are UTF-8 encoded

fn main() {
    // String - owned
    let mut s = String::from("hello");
    s.push_str(" world"); // Can modify

    // &str - borrowed string slice
    let slice: &str = &s[0..5]; // "hello"

    // String literals are &str
    let literal = "I'm a &str";

    // Converting
    let s2: String = literal.to_string();
    let slice2: &str = &s2;
}

Try it in Rust Playground

String vs &str confuses everyone. String is owned data, &str is a view into string data. Think: String is like Vec, &str is like &[u8]. String literals in code are &str with ’static lifetime. This follows ownership from Week 10.

Best practice: Emphasize that functions should almost always accept &str as a parameter instead of String. This is more flexible as you can pass either a String (as &my_string) or a string literal, and it avoids unnecessary memory allocations.

HashMap<K, V>: key-value storage

use std::collections::HashMap;

fn main() {
    // Creating
    let mut scores = HashMap::new();

    // Inserting
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    // Accessing
    let team_name = String::from("Blue");
    let score = scores.get(&team_name);  // Returns Option<&V>

    match score {
        Some(&s) => println!("Score: {}", s),
        None => println!("Team not found"),
    }

    // Iterating
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
}

Try it in Rust Playground

LIVE DEMO: Show HashMap creation, insertion, and lookup. Note that .get() returns Option - the key might not exist! HashMap owns its keys and values. When you insert, ownership moves into the HashMap. This is consistent with ownership rules.

Performance insight: Clarify that HashMap provides amortized O(1) (average constant time) performance for insertions and lookups, which is why it’s so fast. This is a key data structures concept.

Choosing the right collection

Vec<T> - Use when: - You need an ordered list - You want to access by index - You’ll add/remove from the end

String - Use when: - You need owned, growable text - Building strings dynamically

HashMap<K, V> - Use when: - You need key-value lookups - Order doesn’t matter - Fast access by key is important

Choosing collections is a design decision. Vec for lists, HashMap for lookups, String for text. These cover 95% of use cases. There are other collections (BTreeMap, HashSet, etc.) but start with these three. Ask yourself: How will I access this data?

Real-world example: building a phone book

use std::collections::HashMap;

struct Contact {
    name: String,
    phone: String,
    email: Option<String>, // Email is optional
}

fn main() {
    let mut phone_book: HashMap<String, Contact> = HashMap::new();

    phone_book.insert(
        String::from("Alice"),
        Contact {
            name: String::from("Alice Smith"),
            phone: String::from("555-1234"),
            email: Some(String::from("alice@example.com")),
        }
    );

    // Look up by name
    if let Some(contact) = phone_book.get("Alice") {
        println!("Phone: {}", contact.phone);
        if let Some(email) = &contact.email {
            println!("Email: {}", email);
        }
    }
}

Try it in Rust Playground

This example ties everything together: struct for Contact, Option for optional email, HashMap for storage, if let for handling Options. This is how real Rust programs are structured. Show students this is production-quality code.

🤖 AI co-pilot technique: working with collections

When using collections, ask your AI assistant:

Effective prompts: - “Which Rust collection should I use for [describe use case]?” - “Help me convert this Python list comprehension to Rust: [paste code]” - “Show me how to iterate over a HashMap in Rust” - “How do I handle the Option returned by HashMap.get()?” - “What’s the difference between Vec::push and Vec::append?”

Example: “I have a list of user IDs and need fast lookup. Should I use Vec or HashMap?”

Collections have many methods. AI can help find the right one and show idiomatic patterns. Students should ask AI to explain trade-offs (Vec vs HashMap performance), not just provide syntax. Understanding when to use each collection is key.

Introducing Lab 11: data modeling challenge

This week’s lab has three parts:

1. Structs and Enums
   • Model a library system with custom types
   • Use structs for Book/DVD data
   • Use enums for ItemStatus (Available/CheckedOut)
2. Error Handling
   • Return Result from functions that can fail
   • Use Option for optional data
   • Practice the ? operator
3. Collections in Action
   • Store items in Vec<T>
   • Build HashMap<K, V> for fast lookups
   • Iterate and search

Full instructions: week11/lab11.md

Lab 11 applies everything from today. Students will design data structures, handle errors properly, and use collections. This is practical Rust - the kind they’ll write in real projects. Emphasize that this builds on ownership from last week.

Career relevance: production Rust patterns

What you learned today is used daily in industry:

• Discord - Structs for message data, enums for event types
• Dropbox - Result for error handling, HashMap for file tracking
• Cloudflare - Vec for request queues, modules for organization

Interview topics: - “How does Rust handle errors differently than exceptions?” - “When would you use an enum instead of inheritance?” - “Explain Option vs Result”

These patterns aren’t academic - they’re production Rust. Companies choose Rust partly because of these features (Result vs exceptions, enums vs inheritance). Students learning these concepts now are learning industry standards.

Preview: You’ve Been Using Generics!

Notice the angle brackets?

let mut numbers: Vec<i32> = Vec::new();
let result: Result<String, io::Error> = read_file();
let maybe_value: Option<&str> = map.get("key");
let mut scores: HashMap<String, i32> = HashMap::new();

What <T> means: - Vec<i32> = “a vector of i32 values” - Result<String, io::Error> = “success gives String, error gives io::Error” - Option<&str> = “maybe a &str, maybe nothing” - HashMap<String, i32> = “map from String keys to i32 values”

You’ve been using generic types all along!

This is a key realization moment. Students have been using Vec, Option, Result<T, E> without necessarily understanding the generic nature. Point out that the angle brackets always mean “generic over some type”. This primes them for next week where they’ll write their own generic types.

Next Week: Writing Your Own Generics

Week 12 preview - Generics and Traits:

You’ll learn to: - Write generic functions that work with any type - Create generic structs like Stack<T> or Cache<K, V> - Define traits (Rust’s version of interfaces) - Implement traits like Display, Iterator, Clone - Use trait bounds to constrain generic types

Why it matters: - Write reusable code without duplication - Zero runtime cost (Rust generates specialized code) - Type-safe abstractions - Professional Rust development pattern

Teaser: Lab 12 will have you build a generic Stack<T> that works with any type!

Build excitement for next week. Emphasize that they already understand how to USE generics (Vec, Option, Result) - now they’ll learn to CREATE them. This is the jump from consumer to creator. The Stack lab is a classic data structures exercise that demonstrates the power of generics.

Resources for going deeper

Official Rust documentation: - The Rust Book - Chapter 7: Modules - The Rust Book - Chapter 5: Structs - The Rust Book - Chapter 6: Enums and Pattern Matching - The Rust Book - Chapter 9: Error Handling - The Rust Book - Chapter 8: Collections

Interactive practice: - Rust by Example - Modules - Rust by Example - Error Handling - Rustlings - Structs Exercises

All these links are essential reading. Chapter 8 (Collections) and Chapter 9 (Error Handling) are particularly important. Rustlings has great exercises for structs and enums. Encourage students to work through these after the lab.

Questions?

Remember: - Modules organize code, structs/enums organize data - Option<T> eliminates null pointer errors - Result<T, E> makes error handling explicit - Collections (Vec, String, HashMap) follow ownership rules - Use AI to explore design patterns and learn idioms

Lab 11 due: Sunday, November 16 at 11:59 PM

Office hours: Available on Microsoft Teams - reach out anytime!

End on an encouraging note. Today’s content is dense but practical. Every concept (modules, structs, enums, Result, collections) is used daily in production Rust. The lab lets them apply it all. Remind them that understanding ownership makes this week easier.