Pumping up Node.js modules with Rust

These slides were presented at JSConfAU 2018

Talk Description:

If you’ve spent much time writing and debugging node module code for performance in a Js app, you’ve probably had a hard time managing memory and native code integration.

In this talk, we venture deep into the belly of the Rust Language to uncover the secret incantations for building high performance and memory safe node modules using Neon, which helps you to write native node js modules and it is definitely gonna mesmerize you with its easy language bridge capabilities for building high performant and crash-free Js apps.

Rust is out there creating a new generation of system programmers, it has a lot to offer in terms of safety and performance for high-level programming languages such Python, Ruby, Js and more with its easy Foreign Function Interface capabilities which enables developers to easily develop bindings for foreign code.

Transcript

1. JSConf AU 2018 Pumping up Node.js modules with Rust Vigneshwer Dhinakaran | Mozilla TechSpeaker | @dvigneshwer
2. Need of Node.js Native Addon Performance Freedom in memory management low-level API
3. Why Rust? Freedom from Data Race conditions Strong type system High level iterators More control over memory Welcoming Community
4. Facts & Figures
5. Speeding up crypto on Wire desktop apps https://medium.com/@wireapp/speeding-up-crypto-on-wire-desktop-apps-3ff37fc98c3f Up to 141× faster
6. 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/
7. Gradual adoption works.
8. 2016 -18 For the third year in a row, Rust is stackoverflow's most loved language https://insights.stackoverflow.com/survey/2018/
9. Friends of Rust Organizations running Rust in production. (https://www.rust-lang.org/en-US/friends.html)
10. Rust is easy to learn!
11. Variables
12. Functions
13. Flow control
14. Flow control
15. Looping
16. Types
17. Package Manager
18. Ownership The act, state, or right of possessing something
19. Garbage Collection Heap Memory new Circle(5) new Circle(5) new Circle(5)
20. Referencing Now both bookingService and repairService hold a reference to vehicle
21. Same implementation in Rust Doesn't compile!
22. 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
23. Borrowing The act, state, or right of possessing something
24. Making it work in Rust Lending things is the key!
25. 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
26. 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 )
27. Using Rust with Node.js
28. Application to generate Fibonacci numbers /Cargo.toml ~ package.json https://github.com/RisingStack/node-with-rust /src/embed.rs
29. Node.js Integration You are calling Rust from Node.js now!
30. Deep dive into Neon project
31. Getting Started
32. Hello world native/Cargo.toml /native/src/lib.rs https://guides.neon-bindings.com/hello-world/
33. Hello world lib/index.js Build & Run https://guides.neon-bindings.com/hello-world/
34. call.scope eventHandler initObject init_obj init_prop set_prop Object::set setter JavaScript Rust V8 JavaScript GC’ed Heap Memory
35. Benchmarking Execution time : ~ 1 sec
36. Benchmarking Execution time : ~ 250 ms
37. Benchmarking
38. Benchmarking ~ 100 ms
39. Summary
40. 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 • JS to Rust calls are non-trivial, so be wise!
41. What does Rust have to offer? • Modern C/C++ replacement • Memory Safety without Garbage Collection • No runtime needed • Rich Typesystem • Strong Functional Programming influence
42. https://hacks.mozilla.org/2018/03/making-webassembly-better-for-rust-for-all-languages/ The future is exciting!
43. Thanks! @dvigneshwer dvigneshwer@gmail.com https://tinyurl.com/JSConfAU18