Introduction to Rust - Montpellier Rust meetup

Transcript

1. The Rust programming language An introduction Rust meetup • 2018-09-27 •Montpellier - France 1
2. About me Baptiste Back-end engineer Teads (≈ 4 years) @Viewtiful_ Montpellier Slack community: Viewtiful 2
3. History 2006 – Personal project of Graydon Hoare 2009 – Project sponsored by Mozilla 2010 – Official support by Mozilla 2011 – rustc successfully compiled itself after a re-write from Ocaml 2012 – First numbered pre-alpha release – Servo dev started 2015 – 1.0 – first stable release Now & beyond – Stable release every 6 weeks through “rolling release cycle” Steve Klabnik excellent talk on Rust history: https://www.youtube.com/watch?v=79PSagCD_AY 3
4. Motto A systems programming language that runs blazingly fast, prevents segmentation faults, and guarantees thread safety. 4
5. Rust vs. other languages Control Safety C C++ Java Scala Haskell Rust 5
6. Rust vs. other languages Control Safety C C++ Java Scala Haskell Rust 6
7. Rust vs. other languages Control Safety C C++ Java Scala Haskell Rust 7
8. Rust killer features Ownership Borrowing Lifetime Borrow checker 8
9. Let’s try it! 9
10. Rust playground (https://play.rust-lang.org/) 10
11. Rustup (https://www.rustup.rs/) • Install rustc, cargo, standard tools, documentation of the standard library • Guide: https://github.com/rust-lang-nursery/rustup.rs • Release channel: Stable, Beta, Nightly • Update rustup: “rustup self update” • New version of Rust? “rustup update” • Install nightly: “rustup install nightly” • Switch to nightly: “rustup default nightly” • … 11
12. Cargo Rust package manager 12
13. Cargo • Project creation • Handle Rust project’s dependencies • Compilation • Testing • Benchmarking • Packaging • Upload to crate.io (https://crates.io) • Conventions to make working with Rust projects easier (RustFmt, Rust-clippy, …) • Semantic versioning (https://semver.org/) • Documentation: https://doc.rust-lang.org/cargo/index.html • Goal: Ensure that you will always have a repeatable build 13
14. Cargo Project creation Binary 14 Library
15. Cargo Cargo.toml 15 Cargo.lock semver (https://semver.org/)
16. IDE / Editor • Racer (first commit: 4 March 2014): auto-completion tool • Repository: https://github.com/racer-rust/racer • Rust Language Server (first commit: 31 August 2016) : • Runs in the background • Designed to be frontend-independent • Provides information about Rust programs • Uses the compiler and Racer • RFC: https://github.com/rust-lang/rfcs/pull/1317 • Repository: https://github.com/rust-lang-nursery/rls • IDE plugins • Eclipse • IntelliJ IDEA • Visual Studio • Editor plugins • Emacs • Vim • Sublime Text • Atom • Visual Studio Code IDE support tracklist: https://areweideyet.com/ 16
17. Immutability by default 17
18. Mutability is explicit 18
19. Types do not change under the hood, expects type X, you need to give it type X 19
20. Primitive types 20
21. Char (Represents a Unicode Scalar Value) – 4 bytes 21
22. Arrays (fixed-sized arrays) 22
23. Arrays 23
24. Arrays 24
25. Tuples 25
26. Functions 26
27. If condition 27
28. Loops 28 Infinite While with condition For: iterate collections / range
29. Ownership 29
30. Ownership 30
31. Ownership 31
32. Ownership • Every value has a single owner that determines its lifetime • Owner is freed (goes out of scope), the value is also freed 32
33. Ownership Stack 2 2 Heap 2 … 1 … 33
34. Ownership Stack 2 2 Heap 2 … 1 … 2 2 34
35. Ownership Stack Heap 2 … 1 … 2 2 35
36. Ownership Stack Heap 36
37. Ownership Rust compiler error index: https://doc.rust-lang.org/error-index.html 37
38. Ownership To make it works you must pass the values back and forth 38
39. Ownership: Aliasing vs. Mutability Prevents the aliasing but authorize the mutability of the value ✕ Aliasing - ✓ mutability 39
40. Borrowing Would be cumbersome to only have the concept of ownership Concept of borrowing: Able to borrow the value for a short period of time 2 kinds of borrows: • Shared reference (& T) – immutable reference • ✓Aliasing - ✕ mutability • Mutable reference (&mut T) • ✕ Aliasing - ✓ mutability 40
41. Shared reference (& T) Stack 2 2 Heap 2 … 1 … 41
42. Shared reference (& T) Stack 2 2 Heap 2 … 1 … vec 42
43. Shared reference (& T) Stack 2 2 Heap 2 … 1 … 43
44. Shared reference (& T) Stack 2 2 Heap 2 … 1 … 44
45. Mutable reference (&mut T) 45
46. Lifetime <‘a> Lifetimes are here to avoid dangling references Lifetime: Scope for which the reference is valid Used explicitly by the borrow checker Lifetime elision: implicit lifetimes for the programmer But, we sometimes need to be explicit to help the borrow checker understand what we are trying to achieve 46
47. Lifetime <‘a> 47
48. Lifetime <‘a> 48
49. Lifetime <‘a> 49
50. Lifetime <‘a> 50
51. Lifetime <‘a> 51
52. Lifetime <‘a> 52
53. Ownership, borrowing, lifetimes • Enable: • No need for runtime (check at compile time) • Memory safety without GC • No data-races 53
54. Structures • Building blocks for creating new types 54
55. Structures • Methods • Defined in the “impl” block of the structure • First parameters is always “self” (represents the instances of the structure) 55
56. Structures • Associated functions • Used for example to define constructors • Do not take “self” as a parameter 56
57. Enumerations Enumeration are like algebraic data types Define a type by enumerating all its possible values 57
58. Enumerations Optional 58
59. Pattern matching Pattern matching 59
60. Pattern matching Must be exhaustive 60
61. Error handling No exceptions! Unrecoverable errors • Panic! • Debug: “RUST_BACKTRACE=1 cargo run” • By default: • Unwind the stack • Costly, can force abort in “Cargo.toml” 61 Recoverable errors • Enumeration • Pattern match • Shortcut: • Unwrap: if OK -> ✓else “panic!” • Expect: custom error message • Error propagation with ?
62. Error handling Propagating errors 62
63. Traits Defining shared behavior 63
64. Traits Trait bound 64
65. Traits Trait bound 65
66. Traits Multiple trait bound 66 OR
67. Closures 67
68. Closures Type inference 68
69. Closures Implement one of the following trait - Fn : borrowing immutably variables captured - FnMut: borrowing mutably variables captured - FnOnce : Take ownership of the variables it captured from its enclosing scope 69
70. Closures FnOnce 70
71. Iterators 71
72. Implementing an iterator Iterators 72
73. Unit test Only compile the test code when doing a ”cargo test” 73 Best practice: written in the same file
74. Unit test Import function to test 74
75. Unit test Define a test function 75
76. Unit test assertion 76
77. Integration test Each file inside the “tests/” folder are considered an individual crate • Need to import our crate • These tests use crates like any other consumer of it would 77
78. Integration test tests/add_one.rs Import crate 78
79. Integration test tests/add_one.rs Use our function from the crate 79
80. Integration test tests/add_one.rs Use our function from the library 80
81. Box<T>: Allocating values on the heap Smart pointers – Box<T> 81
82. Recursive types Rust must know how much space a type take at compile time Smart pointers – Box<T> 82
83. Recursive types Box<T> to the rescue! Smart pointers – Box<T> 83
84. Reference counting: allow multiple owners Clone = strong reference Counter = 0, no owners -> cleanup Smart pointers – Rc<T> 84
85. Concurrency primitives in the STD 85
86. Concurrency primitives – Spawning a thread 86
87. Concurrency primitives – Data race 87
88. Concurrency primitives – Data race 88
89. Trying to share the data with an Rc<T> Rc<T> is not safe Does not implement the “Send” trait Concurrency primitives 89
90. Using Arc<T> Concurrency primitives 90
91. Mutate data? • Mutex<T> • Atomics Concurrency primitives 91
92. Passing messages through channels Concurrency primitives - Channels 92
93. Debugging • C language Application Binary Interface compatibility • Intellij CLION contains a Rust debugger • Can use GDB and LLDB • Cargo contains wrapper scripts for them in order to enhance the formatting • “rust-gdb” and “rust-lldb” • LLDB • sudo rust-lldb target/debug/deps/project_name-hash 93
94. Who is using Rust? 94
95. Who is using Rust? • Rust itself! 95
96. Who is using Rust? Servo (https://servo.org/) Parts of Firefox: • MP4 metadata parser • Stylo: a pure-Rust parallel CSS engine introduced in Quantum … https://www.rust-lang.org/en-US/friends.html 96
97. Most loved language according to Stack Overflow 3 years in a row!!! 97
98. Community (https://www.rust-lang.org/en-US/community.html) • IRC channels – irc.mozilla.org, #rust, #rust-beginners • https://www.reddit.com/r/rust • Forum: https://users.rust-lang.org/ • Finding Rustaceans: https://www.rustaceans.org/ 98
99. Community –Live streaming https://www.twitch.tv/ferrisstreamsstuff https://www.twitch.tv/mortoray Twitch Rust community: https://www.twitch.tv/communities/rustlang 99
100. This Week in Rust • Handpicked Rust updates, delivered to your inbox. • Weekly newsletter • Subscription page: https://this-week-in-rust.org/ • Jobs offering 100
101. https://readrust.net/ - https://twitter.com/read_rust Curated posts from the Rust programming language community Not officially supported 101
102. Podcasts The Request for Explanation Podcast - Discussion about RFCs https://newrustacean.com/ https://request-for- explanation.github.io/podcast/ Rusty Spike Podcast - A podcast for Rust and Servo https://rusty-spike.blubrry.net/ 102
103. Learning resources • https://rustbyexample.com/ • https://github.com/carols10cents/rustlings • Rust 101: https://www.ralfj.de/projects/rust-101/main.html • Into_rust() – screencast episodes: http://intorust.com/ • Ashley Williams brief intro to the syntax: https://ashleygwilliams.github.io/a-very-brief-intro-to-rust/#1 • GitHub repository referencing them: https://github.com/ctjhoa/rust- learning 103
104. Books Official book Available for free online Release date: December 2017 104
105. Ferris-print macro: https://github.com/kimond/ferris-print 105