IS 4010: Application Development with Artificial Intelligence

Week 09: Welcome to Rust

Brandon M. Greenwell

Session 1: why Rust?

Students are transitioning from Python to a systems language. Acknowledge the steeper learning curve, connect it to the safety guarantees they will study, and show a brief Rust Playground demo.

Welcome to a new frontier

• For the next few weeks, we are shifting from Python to our second language, Rust
• Rust is a modern, compiled language focused on three primary goals: performance, reliability, and safety
• It has a steeper learning curve than Python, but it supports high-performance, memory-efficient programs for domains such as systems programming, game development, and scientific computing
• Created by Graydon Hoare at Mozilla Research in 2006, first stable release in 2015

Historical context: Rust started as a personal project and became one of the most loved languages (Stack Overflow surveys). Emphasize the “performance + safety” combination that makes it unique.

Why Rust matters

• Industry adoption: Used by Microsoft, Amazon Web Services, Google, Meta, and Discord
• Firefox browser: Rust is used in components where performance and memory safety matter
• Linux kernel: The kernel includes Rust support and documentation
• WebAssembly: Rust has mature tooling for targeting WebAssembly
• Developer surveys: The 2024 Stack Overflow Developer Survey reported strong satisfaction among its Rust respondents

Use the linked engineering posts as case studies. Ask what part of each system changed, what metric improved, and which gains came from language features versus redesign or workload differences.

Compiled and interpreted languages

• Python is commonly executed by an interpreter and virtual machine. Its dynamic runtime makes experimentation convenient but adds overhead for some workloads
• Rust is a compiled language. A compiler translates your entire program into machine code (the raw instructions the computer’s CPU understands) before you run it
• This ahead-of-time compilation is a major reason for Rust’s high performance. It catches errors early and optimizes the code for speed
• Bonus: Compiled Rust programs don’t need a runtime or interpreter installed to run

Analogy: interpretation is like translating while reading; ahead-of-time compilation translates before execution. Actual performance depends on the program, libraries, compiler settings, and workload, so benchmark the operation that matters.

Meet cargo, your Rust build tool

• cargo is Rust’s official build system and package manager, and it’s one of the language’s best features
• It handles creating new projects, compiling your code, running your application, and managing external libraries (called “crates” in Rust)
• Think of it as Python’s uv + pytest + formatter + type checker rolled into one tool!
• Cargo provides one interface for the build, test, run, and dependency workflows used in this course

Cargo combines project creation, dependency management, building, testing, and running. Compare that unified experience with our uv plus pytest workflow. Show a live demo: cargo new demo, cd demo, and cargo run. Point out the automatic Git initialization and .gitignore creation.

Essential Cargo commands

Project management: - cargo new project_name: creates a new “Hello, world!” project - cargo init: initialize Cargo in an existing directory

Building and running: - cargo build: compiles your code (debug mode) - cargo run: compiles and runs in one command - cargo build --release: optimized production build

Development workflow: - cargo check: fast compile check (no executable) - cargo test: run all tests - cargo clean: delete build artifacts

Explain that cargo check often gives a faster edit-feedback loop because it checks the crate without producing a final executable. Release builds enable optimizations and usually take longer to compile; runtime improvement depends on the program and should be measured.

Cargo tools: Clippy and rustfmt

cargo clippy - your personal Rust mentor: - Catches common mistakes and suggests better approaches - Over 500 lints for code quality, performance, and style - Provides automated feedback based on established Rust lints - Example: “you can simplify this code” or “this might panic”

cargo fmt - automatic code formatting: - Formats your code to match Rust community style - No more debates about spacing, indentation, or style - Run before every commit - keeps code consistent - Like Python’s black formatter

Live demo: Show Clippy catching a mistake and rustfmt reformatting inconsistent code. Explain that these tools are standard parts of the Rust toolchain and are required in the course workflow.

Your Rust development workflow

Use this repeatable development loop:

1. Write code in your editor
2. cargo check - fast compilation check while coding
3. cargo clippy - catch issues and learn better patterns
4. cargo test - verify your code works correctly
5. cargo fmt - format code before committing
6. cargo run - try out your program

Practice: Use cargo check for quick compiler feedback, then run the full required checks before submitting.

Explain how each command supplies a different kind of evidence. Mention that rust-analyzer can run checks in the editor, but students must still run the required commands before submitting.

Rust Playground: try before you install

• Before installing anything, you can experiment with Rust in your browser at play.rust-lang.org
• The Rust Playground lets you write, compile, and run Rust code instantly
• Useful for testing small examples, sharing snippets, and learning syntax
• Every code example in these slides has a clickable Playground link - try them all!
• You’ll use the Playground extensively in this week’s practice exercises

Live demo: Open Playground and run a Hello World example. Show how to: 1. Edit code and click Run 2. See compile errors in red 3. Use the Share button to save/share 4. Change to different Rust editions Explain that Playground is useful for isolated experiments and shareable examples. Invite students to open it in another tab and follow along.

Live demo: your first Rust code

Open: play.rust-lang.org

Follow along:

1. Click “Run” - see “Hello, world!” in the output
2. Edit the message - change it to your name
3. Click “Run” again - see your personalized greeting!
4. Click “Share” - get a permanent link to save your work

Challenge: Can you make it print TWO lines with different messages?

Pause here for 2-3 minutes - let students actually do this. Walk around (or check screen shares in virtual class) to ensure everyone successfully ran their first Rust code. This builds confidence before diving into syntax.

Hello, Rust

• When you run cargo new hello_rust, it creates a simple project structure for you
• The main source code lives in src/main.rs
• The fn main() function is the entry point for a standard Rust binary
• println! is a macro (not a function, note the !) that prints text to the console

// Inside src/main.rs
fn main() {
    println!("Hello, Rust!");
}

Try it yourself: ▶ Run in Rust Playground

Your turn: Modify the message and add a second println! line!

Point out the exclamation mark and describe a macro as syntax expanded into Rust code during compilation. This week uses standard macros without defining new ones.

Session 2: Rust basics

Second half focuses on syntax fundamentals. Students coming from Python will find the type annotations verbose but precise. Emphasize compile-time safety benefits.

Variables and mutability

• We declare variables using the let keyword
• A core concept in Rust is that variables are immutable by default. Once a value is bound to a name, you can’t change it. This helps us write safer code
• To make a variable mutable, you must explicitly use the let mut keyword
• This is the opposite of Python, where everything is mutable by default!

let x = 5;        // immutable
let mut y = 10;   // mutable
y = 15;           // this is allowed
// x = 6;         // this would cause a compiler error!

Try it yourself: ▶ Experiment in Playground

Challenge: Uncomment the x = 6; line. What error do you get? Read it carefully!

Immutability by default makes mutation explicit and rules out some accidental state changes. Have students uncomment the x = 6 line, then read the diagnostic and identify the suggested change.

Scalar data types

• Rust is a statically typed language, meaning the type of every variable must be known at compile time
• It has four primary scalar (single value) types:
  • Integers: signed (i32, i64) or unsigned (u8, u32). The number is the bits of space it takes up. i32 is the default
  • Floating-point numbers: f32 (single-precision) and f64 (double-precision). f64 is the default
  • Booleans: bool with values true or false
  • Characters: char, for a single Unicode character, denoted with single quotes

Type inference works most of the time - Rust can figure out types. But when it can’t, you’ll get a compile error. Integer types: signed can be negative (i), unsigned cannot (u). Memory conscious choices matter in systems programming.

Text: &str and String

• Text in double quotes, like "Hello", is a string literal. Its type is &str: fixed text built into your program
• String is text your program owns and can grow, created with String::from("Homer")
• Single quotes make a char ('H'); double quotes make a &str ("H")
• The & means “a reference.” Week 10 explains references fully; for now, read &str as “some text you can look at”

let greeting: &str = "Hello";         // A string literal
let mut name = String::from("Homer"); // An owned, growable String
name.push_str(" Simpson");            // Only a mut String can grow
println!("{}, {}!", greeting, name);

Try it yourself: ▶ Run in Playground

Challenge: Remove mut from name. What does the compiler say?

Output: Hello, Homer Simpson!. Lab 09’s string functions use both types: they take &str input and return a new String, as in reverse_string(_s: &str) -> String. That is all students need to read the signatures this week. Removing mut gives E0596 (cannot borrow name as mutable); do not explain borrowing yet, just point out that changing a String needs let mut, the same rule as the previous slide. Week 10 returns to both types and explains the & in full. Python comparison: a Python str is closest to &str in that it never changes; Python has no growable string type.

Compound data types

• Rust has two primary built-in compound types for grouping multiple values
• The tuple is a fixed-size collection of values of different types. Once declared, a tuple’s size cannot change
• The array is a fixed-size collection where every element must have the same type
• For dynamic sizing, we’ll learn about Vectors and HashMaps later

// A tuple with different types
let my_tuple: (i32, f64, u8) = (500, 6.4, 1);

// An array with five elements of the same type
let my_array: [i32; 5] = [1, 2, 3, 4, 5];

Try it yourself: ▶ Run in Playground

Challenge: Try accessing my_tuple.0 and my_array[0]. What do you get?

Arrays are stack-allocated and fast but inflexible. Unlike Python lists, Rust arrays have fixed size. The {:?} is debug formatting - we’ll cover formatting more later. Have students try accessing individual elements by index.

Functions in Rust

• We define functions using the fn keyword
• You must declare the type of each function parameter
• If the function returns a value, you must declare its type after an arrow ->
• The final expression in a function is automatically returned; you don’t need the return keyword if it’s at the end
• This is called an expression-based language - expressions return values, statements don’t

fn add(num1: i32, num2: i32) -> i32 {
    // No semicolon means this is an expression, and it's returned
    num1 + num2
}

Try it yourself: ▶ Run in Playground

Challenge: Add a semicolon after num1 + num2. What error appears? Why?

Key difference from Python: type annotations aren’t optional, they’re required. The semicolon vs no semicolon matters! CRITICAL DEMO: With semicolon = statement (no value). Without = expression (returns value). Have students add the semicolon and read the error message together. This is the #1 beginner mistake!

How do we know our code works?

• In the Python section, we used the pytest library to run our tests
• Rust includes a test harness integrated with Cargo
• We can write tests for our code and run them from the command line using a simple, built-in command: cargo test
• No need to install separate testing libraries - testing is first-class in Rust!

Rust projects commonly keep unit tests beside the code they exercise. Cargo provides one consistent command for discovering and running them.

The anatomy of a Rust test

• Tests are just functions marked with a #[test] attribute
• By convention, they are placed in a special module named tests inside the same file as the code they are testing
• The #[cfg(test)] attribute tells Rust to only compile and run this code when we execute cargo test

fn add_two(a: i32) -> i32 {
    a + 2
}

#[cfg(test)]
mod tests {
    use super::*; // Brings `add_two` into scope

    #[test]
    fn it_adds_two() {
        assert_eq!(add_two(2), 4);
    }
}

The #[test] attribute is Rust’s way of marking test functions. The #[cfg(test)] conditional compilation ensures test code isn’t included in release builds. The use super::* imports everything from the parent module.

Assertion macros

• How do we actually check if our code is correct inside a test? We use assertion macros
• A test passes if the function completes without the macro “panicking” (crashing)
• The most common macros are:
  • assert!(expression): Panics if the expression evaluates to false. Useful for boolean checks
  • assert_eq!(left, right): Panics if the left and right arguments are not equal. This is the one you’ll use most often
  • assert_ne!(left, right): The opposite of assert_eq!. Panics if the arguments are equal

Panicking = Rust’s way of saying “critical error, can’t continue”. In tests, a panic means the test failed. In production code, we handle errors more gracefully with Result types (next week).

Our workflow for Rust labs

• For the Rust labs, we will provide the test suite for you
• Your workflow should be:
  1. Open the supplied Week 09 Cargo project and implement each todo!() in src/main.rs
  2. Do not modify the supplied test module
  3. Run cargo test, cargo fmt, and cargo clippy -- -D warnings
  4. Once all checks pass, commit week09/, push, and inspect the Week 09 badge
• This gives you instant feedback without having to wait for the CI/CD pipeline
• Green tests = you’re ready to submit!

Emphasize the instant feedback loop. Students should be running cargo test constantly as they work. It’s much faster than waiting for GitHub Actions.

Introducing Lab 09

• This week’s lab is your first hands-on introduction to Rust
• Install the Rust toolchain using rustup if it is not already installed
• Open the supplied week09 Cargo project
• Implement arithmetic, string, slice, and vector functions in src/main.rs
• Run the required Cargo test, format, and lint commands
• Full instructions are in week09/lab09.md
• Don’t forget the Rust Playground exercises for extra practice!

Remind students that compiler diagnostics often identify the relevant type or ownership rule and may suggest a correction. Use AI assistants for explanation, then verify the change with Cargo and explain it in your own words.

Resources for learning Rust

• Rust for Python Programmers - Microsoft’s guide written for people arriving from Python
• The Rust Programming Language Book - the official, free, comprehensive guide
• Rust by Example - learn through annotated examples
• Rustlings - small exercises to get you used to reading and writing Rust code
• Rust Users Forum - friendly community for questions
• Microsoft Rust course on YouTube - free video series
• Use your chosen browser, editor, or CLI assistant, then verify every change with Cargo

The Rust community is exceptionally welcoming. The book (often called “the Rust book”) is the gold standard - well-written and free. Rustlings is great for building muscle memory with Rust syntax.