Rust TechSpeakers Workshop Intro

An introduction to Rust covering mutability, borrowing, and ownership (how Rust manages memory without a mandatory garbage collector or reference counting).

Transcript

1. Rust Dan Callahan @callahad Batgirl (2016–) #8
2. Batgirl (2016–) #8
4. ☑ Pop Culture ☐ Programming?
7. …basically every major tech company
10. Meta
11. Releases Editions Tooling
12. Releases “Stability Without Stagnation”
13. Three Channels:
 Nightly → Beta → Stable Releases “Stability Without Stagnation”
14. Three Channels:
 Nightly → Beta → Stable Releases every six weeks (approx.) Releases “Stability Without Stagnation”
15. Three Channels:
 Nightly → Beta → Stable Releases every six weeks (approx.) Experimental Features:
 Only available on Nightly
 Require explicit opt-in Releases “Stability Without Stagnation”
16. Editions
17. New edition every 2-3 years (approx.)
 Call attention to cumulative improvements since prior edition
 Opportunity to change Rust itself (new keywords, semantics, etc.) Editions
18. New edition every 2-3 years (approx.)
 Call attention to cumulative improvements since prior edition
 Opportunity to change Rust itself (new keywords, semantics, etc.) Editions are opt-in
 Default is always Rust 2015 Editions
19. New edition every 2-3 years (approx.)
 Call attention to cumulative improvements since prior edition
 Opportunity to change Rust itself (new keywords, semantics, etc.) Editions are opt-in
 Default is always Rust 2015 Compiler will always support all previous editions
 Rust 2015 code can depend on Rust 2018 code, and vice versa Editions
20. Tooling
21. Rustup — Install and manage Rust itself Tooling
22. Rustup — Install and manage Rust itself Cargo — Main build, test, etc. tool for Rust code Tooling
23. Rustup — Install and manage Rust itself Cargo — Main build, test, etc. tool for Rust code Clippy — Comprehensive code linting tool Tooling
24. Rustup — Install and manage Rust itself Cargo — Main build, test, etc. tool for Rust code Clippy — Comprehensive code linting tool Rustfmt — Automatic code formatting Tooling
25. Rustup — Install and manage Rust itself Cargo — Main build, test, etc. tool for Rust code Clippy — Comprehensive code linting tool Rustfmt — Automatic code formatting RLS — Language Server Protocol implementation for Rust Tooling
26. Rustup — Install and manage Rust itself Cargo — Main build, test, etc. tool for Rust code Clippy — Comprehensive code linting tool Rustfmt — Automatic code formatting RLS — Language Server Protocol implementation for Rust Tooling Works great with Visual Studio Code!
27. Mutability What Borrowing Ownership
28. Mutability What Borrowing Ownership
29. Mutability What Borrowing Ownership
30. Mutability What Borrowing Ownership
31. What is Rust?
32. C’s performance and portability, but with guaranteed safety.
33. C’s performance and portability, but with guaranteed safety.
34. “Systems programming
 without fear.”
35. Julia Evans @b0rk jvns.ca/blog/2016/09/11/rustconf-keynote
36. Julia Evans @b0rk jvns.ca/blog/2016/09/11/rustconf-keynote
37. “It’s not complicated”
38. Mutability
39. Try it fn main() { let x = 5; x += 1; println!("{}", x) }
40. Try it fn main() { let x = 5; x += 1; println!("{}", x) } error[E0384]: re-assignment of immutable variable `x`
41. Try it fn main() { let mut x = 5; x += 1; println!("{}", x) }
42. Try it fn main() { let mut x = 5; x += 1; println!("{}", x) } 6
43. All variables are immutable by default Mutability Rules
44. Borrowing
45. #[derive(Debug)] struct Point { x: i32, y: i32, } fn main() { let mut point = Point { x: 0, y: 0 }; println!("Current value: {:?}", &point); let foo = &mut point; foo.x = 1; foo.y = 2; // What happens if you move this up a few lines, between foo.x and foo.y? println!("Current value: {:?}", &point); }
46. Let’s just Try it
47. Only one mutable borrow at a time
 But as many immutable &’s as you want Mutable borrows block all other access
 The &mut must end before using other &’s Borrowing Rules
48. Ownership
49. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } Stack Heap Try it
50. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } ➟ Stack Heap Try it
51. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } ➟ Stack Heap a b c Try it
52. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } ➟ Stack Heap x PTR LEN CAP a b c 3 3 Try it
53. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } ➟ a Stack Heap x PTR LEN CAP a b c 3 3 Try it
54. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } ➟ ? Stack Heap a b c Try it
55. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } ➟ Stack Heap x PTR LEN CAP a b c 3 3 Owner Try it
56. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } ➟ Stack Heap x PTR LEN CAP a b c 3 3 x Owner Try it
57. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } Stack Heap x PTR LEN CAP a b c 3 3 x Owner ➟ a Try it
58. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } Stack Heap x PTR LEN CAP a b c 3 3 x Owner ➟ a Try it Free x’s memory here
59. fn main() { { let x = vec![‘a’,‘b’,‘c’]; println!(“{}”, x[0]); } } Stack Heap Owner ➟ Try it
60. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } Stack Heap Try it
61. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap Try it
62. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap &Vec<Char> Try it
63. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap &Vec<Char> y Try it
64. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y x PTR LEN CAP a b c 3 3 x Owner Try it
65. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y x PTR LEN CAP a b c 3 3 x Owner Try it
66. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y x PTR LEN CAP a b c 3 3 x Owner a Try it
67. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y Owner Try it
68. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y Owner ? Try it
69. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = &x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y Owner Compiler
 X Try it
70. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } Stack Heap Owner Try it
71. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap Owner Try it
72. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap Vec<Char> Owner Try it
73. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap Vec<Char> y PTR LEN CAP Owner Try it
74. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 x PTR LEN CAP x Try it
75. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 x PTR LEN CAP x Try it
76. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 x PTR LEN CAP 3 3 x Try it
77. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 x PTR LEN CAP 3 3 x Try it
78. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 x PTR LEN CAP 3 3 x y Try it
79. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 x PTR LEN CAP 3 3 x y Try it
80. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 x PTR LEN CAP 3 3 x y Compiler
 X Try it
81. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; // println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 x PTR LEN CAP 3 3 x y Try it
82. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; // println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 y Try it
83. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; // println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 y a Try it
84. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; // println!(“{}”, x[0]); } println!(“{}”, y[0]); } ➟ Stack Heap y PTR LEN CAP Owner a b c 3 3 y a Try it Free y’s memory here
85. fn main() { let y; { let x = vec![‘a’,‘b’,‘c’]; y = x; // println!(“{}”, x[0]); } println!(“{}”, y[0]); } Stack Heap Owner Try it
86. One unique owner per allocation Memory freed when owner leaves scope
 All other references must also be out of scope Ownership can be passed
 Invalidates previous owner Ownership Rules
87. If it compiles, it won’t segfault If it compiles, there are no data races No runtime overhead
 No implicit refcounts, no garbage collector, etc. Rules are enforced by the compiler
88. Ashley Williams @ag_dubs github.com/ashleygwilliams/rustfest-2017
89. Ashley Williams @ag_dubs github.com/ashleygwilliams/rustfest-2017
90. Ashley Williams @ag_dubs github.com/ashleygwilliams/rustfest-2017
91. Ashley Williams @ag_dubs github.com/ashleygwilliams/rustfest-2017
92. Trailheads
93. doc.rust-lang.org/book Carol Nichols @carols10cents
94. rust-lang.org doc.rust-lang.org/book doc.rust-lang.org/rust-by-example play.rust-lang.org Dan Callahan @callahad