GoTo nights: Modern low-level - Rust

Transcript

1. $ cat ~/.profile GIT_AUTHOR_NAME=Florian Gilcher GIT_AUTHOR_EMAIL=florian@asquera.de TWITTER_HANDLE=argorak GITHUB_HANDLE=skade BLOG=skade.me YAKS=yakshav.es
2. r Backend Developer r Rust Trainer r Ruby Programmer since 2003 r Rust Programmer since 2013 r CEO asquera GmbH
3. r Community person r Rust UG Berlin/Karlsruhe r Search UG Berlin r Ex-chair of Ruby Berlin e.V.
4. r Organiser eurucamp/jrubyconf.eu r Organiser RustFest r Part of the global Rust community team
5. r As a hobby, I shoot arrows at stuff
7. Rust
8. r new systems programming language r powers and was developed in along with Servo, a new browser engine r by Mozilla
9. Providing an alternative to C/C++, but also higher-level languages.
10. r Safe r Concurrent r Fast
11. Pick Three
12. We’ve seen all those promises before, but how does Rust differ?
13. Core features
14. r Static type system with local type inference r Explicit mutability r Zero-cost abstractions r Runtime-independent concurrency primitives
15. r Explicit error control flow r No null r Static automatic memory manage- ment r No garbage collection
16. r Built with practical use in mind from the beginning r Features are there for the long run r Still with an eye on ergonomics r Great tooling and docs
17. extern crate tempdir; use tempdir::*; use std::fs::File; fn main() { let tempdir = TempDir::new("mozilla-roadshow"); let mut tempfile = match tempdir { Ok(dir) => { File::create( &dir.path().join("tmp") ) } Err(_) => { panic!("Couldn’t open tempdir") } } // look, no close necessary! }
18. Zero-cost Abstractions
19. extern crate tempdir; use tempdir::*; use std::fs::File; fn main() { let mut tempfile = TempDir::new("mozilla-roadshow") .and_then( |tempdir| { File::create( &tempdir.path().join("tmpfile") ) }) ); //... }
20. Despite using a closure, both ways of writing are basically equivalent.
21. Base concept: Mutability struct InnerData { val: i32 } struct Data { inner: InnerData } fn main() { let d = Data { inner: InnerData { val: 41 }}; d.inner.val = 42; // error: cannot assign to immutable field `d.inner.val` }
22. struct InnerData { val: i32 } struct Data { inner: InnerData } fn main() { let mut d = Data { inner: InnerData { val: 41 }}; d.inner.val = 42; }
23. Base concept: Ownership & Borrowing
24. r Every piece of data is uniquely owned r Ownership can be passed r Or access can be borrowed (muta- ble and immutable)
25. struct Data { value: String } fn main() { let data = Data { value: String::from("Hello Berlin!") }; taking_ownership(data); // data cannot be used here } fn taking_ownership(mut data: Data) { share_immutably(&data); share_mutably(&mut data); }
26. r You can borrow mutably once r Or multiple times immutably r Exclusive: mutable or immutable, never both
27. Mutability runs deep 100, 1000, 10.000 lines of called code, Rust keeps your mutability properties!
28. It is part of all signatures!
29. Rust makes reasoning about large systems more localised by reducing "action at distance".
30. Advanced concurrency checking
31. use std::rc::Rc; fn increment(m: &mut i32) { *m += 1 } fn main() { let ref_counted_integer = Rc::new(43); for i in 1..3 { let mut handle = ref_counted_integer.clone(); std::thread::spawn(move || { increment(&mut handle); // the trait `std::marker::Send` is not implemented for `std::rc::Rc<i32>` }); } }
32. This example could be a concurrency bug in many languages, or even a double-free!
33. Send & Sync
34. Rust has the concept of "sendable" and "syncable" values. The first can cross concurrency boundaries by being moved to the other side, the second allows sharing between.
35. This idea is independent of the used concurrency concept (evented, threading), etc.
36. It also doesn’t impose an approach! Shared-nothing as well as sharing synced values can be expressed!
37. Rust has libraries on top of that, providing threading, channels, and event-based concurrency.
38. r Tokio (https://tokio.rs/) r Rayon (https://crates.io/crates/rayon)
39. Low-level control & safety!
40. r Borrows are just pointers r Values are plain values just like in e.g. C
41. Rust gives you the possibility to opt out of safety, if absolutely necessary!
42. “ Safe code means you can take better risks.” – @QEDunham
43. Abstractions Rust provides higher-level abstractions through Generics and Traits, similar to C++ Templates or Java Generics.
44. The Road to Rust
45. Should you use Rust?
46. Yes!
47. Rust is not a simple language and many of its features are built for the long run. It takes a bit to click.
48. Take your time! The new things are worth it.
49. Rust is approachable r Easy to get an environment setup r Great docs through the book and a (almost) fully documented standard API r Build and depencency management baked in
50. Rust plays well with others r Rust interfaces with C or a C-FFI at almost no or zero cost r Binding generators C and C++ r High-level bindings for some lan- guages (Ruby, JavaScript)
51. Rust is a great partner Rust preserves the conveniences of high-level languages in low-level land
52. We don’t want to be your primary language at all cost, but be the best secondary one.
53. Rust is also built for gradual adoption.
54. Projects using Rust r GStreamer r Servo/Firefox r mononoke mercurial server r Redox OS r RTFM (Real Time For the Masses)
55. GStreamer GStreamer is introducing Rust, currently for plugins.
56. r Rust has better ergonomics at same speed r The 20 last security issues were memory bugs r Multithreading without support is a huge source of bugs
57. r Rust gives latency guarantees GC’ed languages cannot give r Runs well on memory-constrained environments
58. Beyond plain code
59. Commitment to stability r Rust is released every 6 weeks r Rust is backwards-compatible, with huge machinery to encure that r Currently at version 1.19.0
60. Commitment to stability r Rust stable allows no use of unsta- ble features r These are only available in nightly builds
61. Maturity r Code generation is provided through LLVM r No runtime: no bugs in the runtime r Very conservative approach to stdlib adoption
62. Cross-capabilities r rustc is a cross-compiler by default and the whole toolchain is aware r Almost-no-setup cross compilation! (getting better) r Rust supports embedded usecases
63. Great compiler support r rustc provides useful errors and warnings, including hints r currently in-development language server for supporting IDEs
64. Young language Rust is a relatively young language. That means the library ecosystem is in flux.
65. Many important libraries available: r Many protocols (HTTP, etc) r Parsers r Concurrency abstraction libraries
66. We have a huge ongoing effort to bring libraries close to 1.0 to 1.0.
67. Already there: r pre-built binary libs for 48 targets, ready to download r Full and advanced build tooling through cargo r webasm support (unstable)
68. A+ product
69. Lots and lots of infrastructure for CI, quality control and development.
70. Rust nightly usually builds since version 0.4.0.
71. Mozillas support helps there, tremendously!
72. Governance & Community Rust is developed by an in-house team at Mozilla. That does not mean in is dependent on it.
73. Most code changes come from external contributors!
74. All changes go through an open RFC process!
75. Mozilla has great experience with open discussion and processes and it shows!
76. Medium time to merged PR for changes: 6 days!
77. Friendly and active community!
78. Supporting commercial users r regular interviews with prod users, to hear about their issues r the core team can always be spoken to r consulting, development and train- ing available, through integer32 and asquera.
79. Commercial users r Mozilla r Dropbox r Facebook r Chef/Habitat r Theater Dortmund
80. r and 86 others. https://www.rust-lang.org/friends.html
81. Rust is not a hype
82. Rust is bringing safe programming to targets where it was unfeasible before while also bringing new things to the table to compete with other safe languages.
83. We do yearly surveys showing constant growth and improvements.
84. The strongest sub-community is...
85. Europe
86. r Rust Hack & Learn Berlin r 89 Meetups around the world r https://zurich.rustfest.eu
87. https://www.rust-lang.org https://community.rs https://twitter.com/rustvideos http://www.linuxhotel.de/kurs/rust/ http://asquera.de community-team@rust-lang.org