Hacker’s guide to Rust Programming - ACCU 2018

Venture deep into the belly of the Rust programming language design and concepts to uncover the secret incantations to create safe and fast applications

General Description

Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. It won the first place for "most loved programming language" in the Stack Overflow Developer Survey in 2016 and 2017.

But what makes Rust so fast & safe? Starting from the basics, this workshop will walk you through the core design & concepts of Rust Language which includes:

Syntax and keywords in Rust

Concept of ownership and borrowing to understand memory safety & management

Polymorphism using Traits

Error handling in Rust

Package management using Cargo tool

Famous Rust tools like clippy, Rustfmt, Rustup etc

Live demos of web development, FFI to understand different applications

Discover this and more tips to build creating highly concurrent and highly safe systems using Rust.

Transcript

1. ACCU 2018 Hacker’s guide to Rust Programming Vigneshwer Dhinakaran | Mozilla TechSpeaker | @dvigneshwer
2. Zen of Rust Memory Safety without Garbage Collection No runtime needed Rich Typesystem High level iterators Freedom from data race Welcoming Community
3. Facts & Figures
4. Speeding up crypto on Wire desktop apps https://medium.com/@wireapp/speeding-up-crypto-on-wire-desktop-apps-3ff37fc98c3f Up to 141× faster
5. Tokio MiniHTTP The library is a proof-of-concept implementation of a simple HTTP/1.1 server using Tokio. http://aturon.github.io/blog/2016/08/11/futures/
6. 2016 -18 For the third year in a row, Rust is stackoverflow's most loved language https://insights.stackoverflow.com/survey/2018/
7. Friends of Rust Organizations running Rust in production. (https://www.rust-lang.org/en-US/friends.html)
8. History: How did it all begin?
9. Browsers Compete for performance & need Safety at its core
12. Gradual adoption works.
14. Rust is easy to learn!
15. Variables
16. Functions
17. Flow control
18. Flow control
19. Looping
20. Types
21. Package Manager
22. Ownership The act, state, or right of possessing something
23. Garbage Collection Heap Memory new Circle(5) new Circle(5) new Circle(5)
24. Referencing Now both bookingService and repairService hold a reference to vehicle
25. Same implementation in Rust Doesn't compile!
26. Ownership • Rust moves ownership by default • The owner has the right to destroy the thing it owns • The memory is freed as soon as the owned variable goes out of it's scope • Hence vehicle may already be destroyed at the point when it's passed to repair_service • Rust catches these errors at compile time
27. Borrowing The act, state, or right of possessing something
28. Making it work in Rust Lending things is the key!
29. Borrowing • A reference is passed without transferring ownership • One can borrow immutable (&) or mutable (&mut) but not both at the same time • Shared ownership can be achieved through special pointers with runtime checks
30. Mutability Rules • All variables are immutable by default • Only one mutable reference at a time ( But as many immutable &’s as you want ) • Mutable references block all other access (The &mut must go out of scope before using other &’s )
31. Safe memory management without GC
32. High-level iterators Execution time : ~ 250 ms
33. High-level iterators
34. Rayon ~ 100 ms
35. Struct • Structs are like lightweight classes • They can have fields • They can be instantiated
36. Struct But not partially !
37. Struct Rust has option enum for such cases
38. Struct Every Option is either Some and contains a value, or None, and does not. Which makes it explicit (No NullPointerExceptions!)
39. Struct Every Option is either Some and contains a value, or None, and does not. Which makes it explicit (No NullPointerExceptions!)
40. Struct can have methods
41. Struct can have methods
42. Traits • Traits are Rust’s sole notion of interface • Traits can be statically dispatched • Traits can be dynamically dispatched • Traits solve a variety of additional problems beyond simple abstraction
43. Traits
44. Traits
45. Traits Traits can have default implementations
46. Traits Traits can be written for foreign types implementations!
47. Traits Traits can be written for foreign types implementations!
48. Generics What if the app need SmartCarStore as well ?
49. Generics Repetitive code
50. Generics Type safety becomes questionable
51. Generics Better :)
52. Generics Can use trait bounds
53. Generics Can pass any reference to anything that implements the Talk trait It has to be looked up in a vtable at run time ~ DYNAMIC DISPATCH
54. Generics talk is now generic with a Talk trait bound
55. Generics The compiler generates specialized code ~ Static Dispatch Zero -Cost Abstraction !!
56. Enum Error can either be Critical or NonCritical at any one time
57. Error Handling Variants may contain data of any other (mixed) types
58. Error Handling Types can be generic In fact the std library uses a lot of generic enums
59. Error Handling Enums can implement methods
60. Error Handling Enums can implement traits
61. Macros Macros allow us to abstract at a syntactic level
62. Rust Web framework Nickel
63. Web application framework Thin layer on top of pure http (Inspired by express.js)
64. Web application framework Custom middleware
65. Other Salient features • Custom Middleware • JSON Support • Mounting • Error Handling • Encrypted Cookies • Session Support
66. Using Rust with Node.js
67. Application to generate Fibonacci numbers /Cargo.toml ~ package.json https://github.com/RisingStack/node-with-rust /src/embed.rs
68. Node.js Integration You are calling Rust from Node.js now!
69. Deep dive into Neon project
70. Getting Started
71. Hello world native/Cargo.toml /native/src/lib.rs https://guides.neon-bindings.com/hello-world/
72. Hello world lib/index.js Build & Run https://guides.neon-bindings.com/hello-world/
73. call.scope eventHandler initObject init_obj init_prop set_prop Object::set setter JavaScript Rust V8 JavaScript GC’ed Heap Memory
74. Rust Tools
75. Tools • rustup: the Rust toolchain installer • rustfmt : the Rust code formatting tool • rust-clippy : Rust code linter • Cargo : package manager • ...
76. 76 Community Photo credit: David McSpadden https://www.flickr.com/photos/familyclan/15535822737/
77. 77 RFC Process
79. Summary
80. When should you use Rust? • Rewrite modules of your code that are computationally heavy (Complex math optimizations etc) • For accessing the hardware(ex :- IOT applications, device drivers, GPU’s etc) • Implementing advance concurrency paradigms • Rust FFI calls are non-trivial, so be wise!
81. What does Rust have to offer? • Modern C/C++ replacement • Memory Safety without Garbage Collection • No runtime needed • Rich Typesystem • Strong Functional Programming influence
82. Thanks! @dvigneshwer dvigneshwer@gmail.com https://tinyurl.com/accurust