Rust is a systems programming language that is fast, memory-efficient, and safe. It was created by Mozilla Research in 2010 and released in 2015. Rust uses a borrow checker to ensure memory safety at compile time without using garbage collection. It is suitable for writing system software, embedded applications, and web assembly. Rust aims to prevent common concurrency bugs and provides features like strong typing, pattern matching, and macros.

1. The Rust Programming Language
A gentle introduction

2. Mario A. Santini
Software Developer
Telco field

3. What is Rust
●
A language for system programming
●
Created by Mozilla (2010~, 2015 v1.0)
●
Multi paradigm, fast, productive and safe
●
“Fearless concurrency”
●
Community Driven and Open Source (MIT lic.)

4. Why we need it?
●
A replacement of C/C++ (mostly C++)
●
A powerfull type system
●
Zero cost of abstraction
●
Safety with the borrow checker
●
Highly memory controll without a GC
●
Rustup, cargo, rustfmt...

5. Where you should use it?
●
System code as alternative of C/C++ or where you
should have bindings with such libs
●
System code as an alternative of Java or Go where you
need more precise control of the memory (no GC)
●
Embedded applications
●
Bar metal
●
WebAssembly and more...

6. The strenghts?
●
Many concurrency bugs are almost impossible!
●
Strong memory handling checks!
●
Enums first class citizens!
●
Explicit error handling!
●
No NULL, null, nil…!
●
Powerfull Pattern Matching!
●
Macro!

7. ...and more features…
●
Dependency handling included (cargo)
●
Documentation included (/// + rustdoc)
●
Linter included
●
Test/Examples/Bench included
●
RLS (rust-analyzer)...

8. Data Types
Length Signed Unsigned FP Bool Char
8-bit i8 u8 - true/false -
16-bit i16 u16 - - -
32-bit i32 u32 f32 - ‘ ’😻
64-bit i64 u64 f64 - -
128-bit i128 u128 - - -
arch isize usize - - -
Compund Types
tuple
array
Enum Struct Smart Pointer Raw Pointer Generics Trait
Strings Types
str
String

9. Ownership Rules
●
Each value in Rust has a variable that’s called its
owner
●
There can only be one owner at a time
●
When the owner goes out of scope, the value
will be dropped

10. Ownership some examples
let my_var = String::from(“Hello Developer Thursday!”);
require_ownership(my_var); // ← move ownership
println!(“My var {}”, my_var); // ← can’t be done!
…
let another_var = String::from(“Hi Developer Thursday!”);
just_borrow_it(&another_var); // ← notice the &
println!(“Another {}”, another_var); // ← now it’s fine!!
…
let mut mutable_var = String::from(“Hi ”);
requiere_mutable_borrow(&mut mutable_var); // this is possible as Rust guarantee there will
// just 1 reference to mutable_var
println!(“A mutable var {}”, mutable_var);

11. Lifetime
fn just_a_function<’a>(
haystack: &’a str, needle: &’a str
) → Option<&’a str> {
let found = haystack.find(needle)?;
let result = &haystack[found..needle.len()];
Some(reuslt.as_ref())
}

12. Ownership and structs
struct MyStruct { … }
impl MyStruct {
fn method_that_borrow(&self, …) { … }
fn method_with_mutable_borrow(&mut self, …) { … }
fn method_that_take_ownership(self, …) { … }
}

13. Multithreading vs Async
Multithreading → good for parallelization
Async → good for concurrecy
Native OS threads
async / .await
+ runtime
(tokio / async-std)
No Green Thread anymore in the language

14. But how fast it can be?
ripgrep: https://blog.burntsushi.net/ripgrep/

15. A closer look...
ripgrep: https://blog.burntsushi.net/ripgrep/

16. Discord Switching From Go to Rust
https://blog.discordapp.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f

17. Rust for the web
Seed: Rust framework for creating fast and reliable web apps with a structure that follows the Elm
Architecture.
Percy: A modular toolkit for building interactive frontend browser apps with Rust + WebAssembly.
Supports server side rendering.
Yew: Rust / Wasm client web app framework with architecture inspired by Elm and Redux. Yew is
based on stdweb that has a lot of features.
Draco: A Rust library for building client side web applications with WebAssembly modeled after the
Elm architecture and Redux.
Smithy: A front-end framework for writing WebAssembly applications entirely in Rust. Its goal is to
allow you to do so using idiomatic Rust, without giving up any of the compiler's safety guarantees.
squark: Rust frontend framework, for web browser and more with architecture inspired from Elm
and HyperApp.
Dodrio: A fast, bump-allocated virtual DOM library for Rust and WebAssembly.
rust-dominator: Zero cost declarative DOM library using FRP signals for Rust!

18. WASM
It’s a standard from W3C
Run inside the
browsers
Can be written in any
LLVM supported
language
Safe
Open and debuggable
Efficient and fast
It’s not JavaScript
https://webassembly.org/

19. WASM: Why Rust?
Rust
C/C++
AssemblyScript
TinyGo
Graalvm (just recently)

20. WASI
The WebAssembly System Interface
March 2019: Standardizing WASI: A system interface to run WebAssembly
outside the web
https://hacks.mozilla.org/2019/03/standardizing-wasi-a-webassembly-system-interface/
C / Rust
It’s a standard as a subgroup of the W3C
WebAssembly CG
https://wasi.dev/

21. Bytecode Alliance

22. Wastime
●
A runtime to run WASM + WASI application on the server
●
Written in Rust!
●
Safe as the application is sandboxed as it runs inside a browser
●
Fast as WASM is a compact and efficient format
●
Lightwight as you just need the runtime
●
Portable the format is standard on every architecture, just need the
runtime!
●
Polyglot wastime can be ported to different languages, and so you can
import librearies written in Rust and compiled in WASM and then
loaded as a Python module!

23. Krustlet
●
A kubelet rewritten in Rust, that runs WASM
programs
●
No need of containers images anymore
●
No need of an OS anymore!
●
And Krustlet can run without any OS too!!

24. Resources
●
Rust lang official site: https://www.rust-lang.org/
●
Crates.io: https://crates.io/
●
Rustup: https://rustup.rs/
●
Cargo: https://doc.rust-lang.org/cargo/
●
Rust book: https://doc.rust-lang.org/book/
●
Rustonomicon: https://doc.rust-lang.org/nomicon/
●
Rust by examples: https://doc.rust-lang.org/rust-by-example/
●
Rust cheat sheet: https://cheats.rs/
●
Rust users community: https://users.rust-lang.org/
●
Rust youtube channel: https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA
●
Rust github: https://github.com/rust-lang/rust
●
Discord Rust streames channel: https://discord.com/channels/234804991343198210/749624598860922890
●
Rust playground: https://play.rust-lang.org/
●
Discord move to Rust: https://blog.discordapp.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f
●
WebAssembly: https://webassembly.org/
●
WASI: https://wasi.dev
●
Krustlet: https://github.com/deislabs/krustlet
●
Bytecode Alliance https://bytecodealliance.org/

25. Thanks!