Slide 1

Slide 1 text

Rust Rust Sibi Prabakaran ILUGC, Oct 10, 2020

Slide 2

Slide 2 text

Agenda Agenda My experience with Rust Introduc on to Rust Why Rust

Slide 3

Slide 3 text

My experience My experience Embedded programming STM32F3 Microcontroller Some work in my day job h ps:/ /crates.io/crates/credstash

Slide 4

Slide 4 text

Rust Rust

Slide 5

Slide 5 text

Heap and Stack Heap and Stack Heap: Memory set aside for dynamic alloca on. Stack: Memory set aside for a thread.

Slide 6

Slide 6 text

Ownership rules Ownership rules Each value in Rust has a variable that’s called its owner. There can only be one owner at a me. When the owner goes out of scope, the value will be dropped. { let s1 = String::from("hello ilugc"); // s1 is valid from this point forward // do stuff with s1

Slide 7

Slide 7 text

} // this scope is now over, and s1 is no // longer valid

Slide 8

Slide 8 text

Data interaction Data interaction fn main() { let x: i32 = 5; let y = x; println!("Output: {} {}", x, y); } fn main() { let x = String::from("hello ilugc"); let y = x; println!("Output: {} {}", x, y); }

Slide 9

Slide 9 text

Ownership Ownership fn main() { let s = String::from("hello"); // s comes into scope takes_ownership(s); // s's value moves into the function... // ... and so is no longer valid here let x = 5; // x comes into scope makes_copy(x); // x would move into the function, // but i32 is Copy, so it’s okay to still // use x afterward

Slide 10

Slide 10 text

References References fn main() { let s1 = String::from("hello"); let len = calculate_length(&s1); println!("The length of '{}' is {}.", s1, len); } fn calculate_length(s: &String) -> usize { s.len() }

Slide 11

Slide 11 text

References (2) References (2) fn main() { let mut s = String::from("hello"); change(&mut s); } fn change(some_string: &mut String) { some_string.push_str(", world"); }

Slide 12

Slide 12 text

Snippet 1 Snippet 1 fn main() { let mut x = String::from("ilugc"); let r1 = &mut x; let r2 = &mut x; println!("{}", r1); }

Slide 13

Slide 13 text

Snippet 2 Snippet 2 fn main() { let mut x = String::from("ilugc"); let r1 = &x; let r2 = &mut x; println!("{}", r1); }

Slide 14

Slide 14 text

Snippet 3 Snippet 3 use std::thread; fn main() { let v = vec![1, 2, 3]; let handle = thread::spawn(|| { println!("Here's a vector: {:?}", v); }); handle.join().unwrap(); }

Slide 15

Slide 15 text

Hard parts Hard parts Learning curve Embedded ecosystem not mature yet. Scien fic libraries.

Slide 16

Slide 16 text

Why Rust Why Rust Compile me guarantees Zero cost abstrac on No excep ons. So easy FFI integra on. Error messages Community

Slide 17

Slide 17 text

Learning Learning resources resources Rust book OReily’s book Embedded book

Slide 18

Slide 18 text

Questions Questions