Rust: Systems Programming for All!

Transcript

1. 1.

   1 Systems Programming for All! Systems Programming for All!

2. 2.

   2 What is Rust all about? Elegant code that runs

   fast. Code that does the right thing.
3. 3.

   3 Two years old on May 15! •••

4. 4.

   4

5. 5.

   5 Photo credit: tao lin https://www.flickr.com/photos/taolin/8639700222/

6. 6.

   JavaScript / Ruby / Python / Java / C# /

   … 6 Virtual Machine or Runtime Native library C / C++
7. 7.

   7 Images used without permission.

8. 8.

   8 Algorithm “Learn All The Things”: Find shelf S with

   computer books. Let N = 1. While less than N books on shelf S { Borrow the Nth book from shelf S. Read it and return it. N = N + 1. }
9. 9.

   9 Images used without permission.

10. 10.

    10 Images used without permission.

11. 11.

    11 C / C++

12. 12.

    [0] 12 void example() { vector<string> shelf; shelf.push_back(…); for (auto&

    book : shelf) { read(book); shelf.push_back(…); } } capacity length data [1] [2] [3] book shelf
13. 13.

    13 Crash, read random data, wev C/C++ Java Throw exception

    JavaScript Do… something Python Something… slightly different Rust? Detect problem when compiling Iterator invalidation: modify while iterating ==> Runtime Error
14. 14.

    14 foo.rs <machine code> <input> <output> “compilation” “execution” Rust: check

    ownership + borrowing Others: something goes wrong here
15. 15.

    “not mutable” owns [0] 15 capacity length data [1] [2]

    1. Every value is owned by a single variable. owns moved ~~~~~~~~~~~~~~~~ (a) Owner gets to decide whether it is mutable. ✅ ❌ ❌ “moved” ~~~~~~~~~~~~~~~~ fn example() { let mut shelf = Vec::new(); shelf.push(…); let shelf2 = shelf; shelf.push(…); print(shelf2.len()); shelf2.push(…); }
16. 16.

    borrows owns [0] 16 capacity length data [1] [2] `shelf`

    borrowed here book ~~~~~~~~~~~~~~~~ 2. Shared borrows make the value temporarily immutable. fn example() { let mut shelf = Vec::new(); shelf.push(…); for book in &shelf { read(book); shelf.push(…); } shelf.push(…); } ❌ “immutable while borrowed” ✅
17. 17.

    “mutably borrowed” owns [0] 17 capacity length data [1] [2]

    `shelf` mutably borrowed here book ~~~~~~~~~~~~~~~~~~~~~ 3. Mutable borrows have unique access to the value. borrows mutably ❌ ✅ ✅ make changes fn example() { let mut shelf = Vec::new(); shelf.push(…); for book in &mut shelf { edit(book); print(shelf.len()); } shelf.push(…); }
18. 18.

    18 1. Every value is owned by a single variable.

    2. Shared borrows make the value temporarily immutable. 3. Mutable borrows have unique access to the value. shelf shelf book shelf book
19. 19.

    19 Recap: Mutation while iterating C/C++ Maximally efficient Maximally dangerous

    Others Less efficient Risky ⛈⛈ Rust Maximally efficient Perfectly safe
20. 20.

    20 “Must be this tall to write multi-threaded code” Idea

    credit: David Baron Mozilla Engineer Extraordinaire and All-Around Great Guy
21. 21.

    21 Shared state and threads Message-passing Data parallelism C and

    C++, Java, C#, … C and C++, Java, C#, … Erlang, Go, JavaScript, … Rust Rust Rust Futures and Async I/O JavaScript, C#, … Rust
22. 22.

    22 Message-passing

23. 23.

    23 let book = channel.receive(); read(book); 1. Every value is

    owned by a single variable. ❌ “moved” moved let book = …; channel.send(book); ~~~~~~~~~~~~
24. 24.

    24 Data parallelism

25. 25.

    25 fn load_images(paths: &[PathBuf]) -> Vec<Image> { paths.iter() .map(|path| {

    Image::load(path) }) .collect() } For each path… …load an image… …create and return a vector. paths = [ “a.jpg”, “b.png”, …, “c.jpg” ] borrowed from caller
26. 26.

    26 fn load_images(paths: &[PathBuf]) -> Vec<Image> { paths.par_iter() .map(|path| {

    Image::load(path) }) .collect() } Make it parallel paths = [ “a.jpg”, “b.png”, …, “c.jpg” ] extern crate rayon; Third-party library
27. 27.

    27 fn load_images(paths: &[PathBuf]) -> Vec<Image> { let mut jpgs

    = 0; paths.par_iter() .map(|path| { if path.ends_with(“.jpg”) { jpgs += 1; } Image::load(path) }) .collect() } How many jpgs seen so far? …add 1 to the counter. If current file name ends in “jpg”… 0 0 + 1 0 + 1 1 1 1
28. 28.

    28 borrows mutably 1. Every value is owned by a

    single variable. 3. Mutable borrows have unique access to the value. fn load_images(paths: &[PathBuf]) -> Vec<Image> { let mut jpgs = 0; paths.par_iter() .map(|path| { if path.ends_with(“.jpg”) { jpgs += 1; } Image::load(path) }) .collect() }
29. 29.

    fn load_images(paths: &[PathBuf]) -> Vec<Image> { let mut jpgs =

    0; paths.par_iter() .map( ) .collect() } 29 borrows mutably borrows mutably |path| { if path.ends_with(“.jpg”) { jpgs += 1; } Image::load(path) } |path| { if path.ends_with(“.jpg”) { jpgs += 1; } Image::load(path) } 3. Mutable borrows have unique access to the value. ~~~~~~~~~ ❌ ~~~~~~~~~ ❌
30. 30.

    30 Recap: Parallel execution Others Flexible ✅✅✅ Maximally dangerous Restrictive

    Perfectly safe Rust Flexible ✅✅✅ Perfectly safe
31. 31.

    31 More examples… ( Foo vs Option<Foo> ) No null

    pointers Robust error handling Generic programming …
32. 32.

    32 Unsafe

33. 33.

    Rust 33 Ownership and Borrowing Unsafe Code Raw Computer

34. 34.

    fn pass_safely(…) { if !car_coming() { } } Safe abstractions

    unsafe { drive_in_left_lane(); } Trust me. Validates input, etc. 34
35. 35.

    35 Community Photo credit: David McSpadden https://www.flickr.com/photos/familyclan/15535822737/

36. 36.

    36

37. 37.

    37 From http://jvns.ca/blog/2016/09/11/rustconf-keynote/ Open and welcoming

38. 38.

    38 https://www.meetup.com/BostonRust/
 Next meetup: June 28 in Cambridge http://boston-rust.herokuapp.com/ Boston

    area Worldwide rust-lang.org
 irc.mozilla.org, #rust, #rust-beginners doc.rust-lang.org/nightly/book/second-edition/ intorust.com ❤ A lso, stickers!