Rust for Serious Developers

An introduction for what Rust is, what makes it special and why it's not just a toy language but solving some real problems and will become an important tool of every technology stack.

1. Rust For Serious Developers Armin @mitsuhiko Ronacher
2. )J
   *N
   "SNJO 
   BOE
   *
   EP
   0QFO
   4PVSDF 'MBTL
   +JOKB
   4FOUSZ
   j
5. Sentry Loves Rust
6. Symbolication
8. Source Map Expansion
10. Command Line Tool
12. Hello Rust
13. Ocaml C++ Haskell Erlang Scheme C# ADT, Pattern Matching RAII, Smart Pointers Typeclasses Message Passing, Failures Hygienic Macros Attributes
14. fn main() { println!("Hello, World!"); }
15. The Toolchain
16. is so good
17. curl https://sh.rustup.rs -sSf | sh https://win.rustup.rs or on windows
18. rustup the rust toolchain manager
19. rustc the rust compiler
20. cargo the rust package manager
21. rustdoc the rust documentation builder
22. Quickstart
23. $ cargo new --bin hello-rust Created binary (application) `hello-rust` project $ cd hello-rust $ cargo run Compiling hello-rust v0.1.0 (file:///private/tmp/hello-rust) Finished debug [unoptimized + debuginfo] target(s) Running `target/debug/hello-rust` Hello, world!
24. Release Channels
25. stable new release every 6 weeks
26. beta upcoming stable release
27. nightly includes unstable features
28. $ rustup override set nightly info: using existing install for 'nightly-x86_64-apple-darwin' info: override toolchain for '/private/tmp/hello-rust' set to 'nightly-x86_64-apple-darwin' nightly-x86_64-apple-darwin unchanged - rustc 1.17.0-nightly (0648517fa 2017-02-27)
29. The Ecosystem
30. crates.io repository of reusable rust crates
31. docs.rs documentation for all crates
32. The Features
33. ADTs
34. enum JsonValue { Null, Bool(bool), Number(f64), Str(String), List(Box<Vec<JsonValue>>), Object(Box<HashMap<String, JsonValue>>), }
35. fn main() { let value = JsonValue::Str("Hello World!".to_string()); match value { JsonValue::Str(ref string) => { println!("JSON value as a string: {}", string); }, _ => { println!("JSON value was something else"); } } }
36. explicit error propagation
37. use std::{fs, env, io}; fn list_current_dir() -> Result<(), io::Error> { let here = env::current_dir()?; for dent_rv in fs::read_dir(here)? { let dent = dent_rv?; let md = dent.metadata()?; println!("{: <60}{: <12}{}", dent.path().display(), md.len(), if md.is_file() { "file" } else { "dir" }); } Ok(()) } fn main() { list_current_dir().unwrap(); }
38. strong types and inference
39. use std::{fs, env, io}; use std::collections::HashMap; fn count_extensions() -> Result<(), io::Error> { let mut counts = HashMap::new(); for dent_rv in fs::read_dir(env::current_dir()?)? { if let Some(ext) = dent_rv?.path().extension() { *counts.entry(ext.to_string_lossy().into_owned()).or_insert(0) += 1; } } let mut items = counts.into_iter().collect::<Vec<_>>(); items.sort_by_key(|&(_, value)| -value); for (ext, count) in items { println!("{: >5} {}", count, ext); } Ok(()) } Result Type OS Str -> String Hash Table Entry Vector of Tuples
40. data vs behavior
41. struct User { id: u64, username: String, } impl User { fn new(id: u64, username: &str) -> User { User { id: id, username: username.to_string(), } } fn username(&self) -> &str { &self.username } }
42. it's all about traits
43. use std::fmt; impl fmt::Debug for User { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "<User {} (id={})>", &self.username, self.id) } }
44. compiler plugins
45. #[derive(Debug, Clone, Serialize, Deserialize)] struct User { id: u64, username: String, }
46. memory safety
50. so how does rust do it?
51. lifetimes move semantics ADTs smart pointers bounds checking explicit unsafe Reason about Memory Track where stuff goes No Null-Pointers Runtime Lifetimes Panic on OOB The Escape Hatch
52. struct SdkInfo { name: String, version: String, } struct SdkInfo<'a> { name: &'a str, version: &'a str, } struct SdkInfo<'a> { name: Cow<'a, str>, version: Cow<'a, str>, }
53. fn main() { let items = vec![1, 2, 3]; let sitems = items.into_iter().map(|x| x.to_string()).collect::<Vec<_>>(); println!("Converted {} items to strings", items.len()); } error[E0382]: use of moved value: `items` --> fail.rs:4:46 | 3 | let sitems = items.into_iter().map(|x| x.to_string()).collect::<Vec<_>>(); | ----- value moved here 4 | println!("Converted {} items to strings", items.len()); | ^^^^^ value used here after move | = note: move occurs because `items` has type `std::vec::Vec<i32>`, which does not implement the `Copy` trait error: aborting due to previous error
54. free parallelism
55. extern crate rayon; fn quick_sort<T: PartialOrd + Send>(v: &mut [T]) { if v.len() > 1 { let mid = partition(v); let (low, high) = v.split_at_mut(mid); rayon::join(|| quick_sort(low), || quick_sort(high)); } } fn partition<T: PartialOrd + Send>(xs: &mut [T]) -> usize { let pivot = xs.len() - 1; let mut i = 0; for j in 0..pivot { if xs[j] <= xs[pivot] { xs.swap(i, j); i += 1; } } xs.swap(i, pivot); i } Values that order & can be sent to threads Spawn two threads and join split mutable slice into two
56. struct Server { ctx: Arc<Context>, } impl Server { pub fn run(&self) -> Result<()> { let ctx = self.ctx.clone(); Server::http("127.0.0.1:3000")? .handle(move |req: Request, resp: Response| { let local_ctx = ctx.clone(); ... } } } increments refcount and returns new Arc
57. Should you use it?
58. maybe!
59. Python Modules
60. Redis/Nginx Modules
61. Command Line Tools
62. Native Libraries
63. One-Trick-Pony API Servers
64. Our Experience
65. code is very readable
66. compile times suck
67. crate ecosystem is great
68. highly maintainable
69. QA &