IS4010: AI-Enhanced Application Development

Week 09: Welcome to Rust

Brandon M. Greenwell

Session 1: Why Rust?

Open with energy - students are transitioning from Python to a systems language. Emphasize that Rust is challenging but incredibly rewarding. Show brief demo of Rust Playground.

Housekeeping: midterm project

• Reminder: Your midterm project is due this Sunday at 11:59 PM!
• Make sure you’ve tested your code locally and pushed all changes to GitHub
• The automated grading system will run on Monday morning
• If you have questions, reach out on Teams before Sunday

Check in with students about midterm progress. Offer to answer quick questions after class.

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 gives us the power to write incredibly fast and memory-efficient code, which is essential for systems programming, game development, and high-performance 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 in 2025

• Industry adoption: Used by Microsoft, Amazon Web Services, Google, Meta, and Discord
• Firefox browser: Large portions rewritten in Rust for performance and security
• Linux kernel: Rust support added in 2022 for driver development
• WebAssembly: Rust is the #1 language for WebAssembly development
• Job market: Consistently highest-paid programming language in Stack Overflow surveys

Real-world relevance: Discord saw 10x performance improvements switching from Go to Rust. Dropbox uses Rust for their file synchronization engine. This isn’t academic - this is what industry needs.

Compiled vs. interpreted languages

• Python is an interpreted language. An interpreter reads and executes your code line by line. This makes it flexible and easy to use, but it can be slower
• 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: Interpreted = simultaneous translation (slower, more flexible). Compiled = translating an entire book before reading (upfront work, but faster execution). Rust can be 10-100x faster than Python for CPU-intensive tasks.

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 pip + pytest + black + mypy all rolled into one amazing tool!
• Cargo is why Rust development feels so smooth and professional

Cargo is like pip + pytest + setuptools all in one tool. It’s incredibly well-designed. Show live demo: cargo new demo && cd demo && cargo run. Point out the automatic git init 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

Emphasize cargo check - it’s MUCH faster than cargo build because it doesn’t generate an executable. Use it constantly while coding! cargo build –release is 10-100x faster than debug builds but takes longer to compile.

Cargo’s secret weapons: 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 - Like having a senior Rust developer review your code - 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. Show fmt before/after messy code. Explain that these come with rustup, no separate install needed. Emphasize that using these tools is NOT cheating - it’s professional Rust development. All Rust developers use them.

Your Rust development workflow

This is what professional Rust developers do:

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

Pro tip: Run cargo check constantly. It’s 10x faster than cargo build!

This is the actual workflow. cargo check gives you immediate feedback. clippy teaches you better Rust. fmt keeps code clean. Get students in this habit NOW. Mention that VS Code with rust-analyzer runs cargo check automatically in the background.

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
• Perfect for testing small examples, sharing code 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 now 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 Mention that professional Rust developers use Playground daily for quick experiments and collaboration. Encourage students to open Playground in another tab RIGHT NOW and follow along.

🎮 Live Demo: Your first Rust code!

👉 Everyone open this link NOW: 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() block is the entry point for every Rust executable
• 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 - macros are a powerful Rust feature. They’re code that writes code. We’ll use them without creating our own for now. Give students 30 seconds to try it in Playground.

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!

Why immutable by default? Prevents entire categories of bugs (race conditions, unexpected mutations). If you need to change a value, you declare that intent upfront. HAVE STUDENTS uncomment the x = 6 line in Playground to see the compiler error. The error message is incredibly helpful - point this out!

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.

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 has a powerful testing framework built directly into the language and its tooling
• 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!

Testing culture in Rust is strong. Most crates (libraries) have excellent test coverage. Cargo makes it effortless - tests live alongside code.

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. Write your solution code in src/main.rs
  2. Append our provided test module to the bottom of that file
  3. Run cargo test in your terminal to check your work locally
  4. Once all tests pass, commit and push your code to GitHub
• 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
• You’ll install the Rust toolchain using rustup
• Create your first Cargo project
• Practice with variables, data types, and functions
• Write and run tests with cargo test
• Full instructions are in labs/lab09/README.md
• Don’t forget the Rust Playground exercises for extra practice!

Remind students: Rust has a steeper learning curve, but the compiler is incredibly helpful. Read the error messages - they often tell you exactly how to fix the problem. Use AI assistants, but make sure you understand the code.

Resources for learning Rust

• 📖 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 GitHub Copilot and Claude - but always understand the code!

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.