Be pinched by a cRUSTacean to prevent programming errors !

3/27/2019 Be pinched by a cRUSTacean to prevent programming errors !
localhost:8000/rust/?print-pdf#/ 1/49
RUSTRUST
Be pinched by a cBe pinched by a cRUSTRUSTacean to prevent programmingacean to prevent programming
errors !errors !

2 words about us2 words about us
$ cat ~/.bash_profile
NAME="René Ribaud"
AGE=43
source ./1998.sh
PROFESSION="Unices system and storage"
"administrator , since 2003"
HISTORY="Lots (too many) infrastructure"
"implementation projects"
"Discover Linux & FLOSS between"
"1995 / 2000"
"First step in the cloud around 2011"
", pre-sales solution architect"
"2014 (Cloud, DevOps)"
"I’m an Ops !"
COMPANY="CGI 20th November 2017"
JOB="Information system architect"
"specialized around DevOps technologies"

2 words about us2 words about us
François BestFrançois Best
Freelance Developer
Embedded/Realtime C/C++
background
Seduced by the Dark Side of the Web
Current interests:
Rust (of course)
Security / Cryptography
Decentralisation
Personal data protection
& de-GAFAMing
Github: |
Web:
@franky47
@47ng
francoisbest.com

What is RUST ?What is RUST ?
New systems programming language
Multi paradigm language (imperative, functional, object
oriented (not fully))
By Mozilla and the Community
Dual license MIT and Apache v2.0
First stable release May 15th, 2015
Rust 2018 (v1.31), a major new edition released
December 6th, 2018

Goal ?Goal ?
Provide an alternative to C/C++ and also higher-levelProvide an alternative to C/C++ and also higher-level
languageslanguages

Why is this Ops guy speaking about aWhy is this Ops guy speaking about a
programming language ?programming language ?

Immune to coder disease 1Immune to coder disease 1
My language is the best !My language is the best !
And my code is also the best !And my code is also the best !
This is part of my job to know languages and especially how to build projects usingThis is part of my job to know languages and especially how to build projects using
themthem

Immune to coder disease 2Immune to coder disease 2
I don't make mistakes, only bad coders are making onesI don't make mistakes, only bad coders are making ones
Really, how do you explain all major projects security issues ?Really, how do you explain all major projects security issues ?
I'm fed up about segfaults and null pointer exceptions !I'm fed up about segfaults and null pointer exceptions !

Why is RUST exciting to me ?Why is RUST exciting to me ?
And probably why should you look at it ?And probably why should you look at it ?

PromisesPromises
Focus on safety -> avoids errors and helps finding them
!
Especially safe concurrency
Fast, really fast !

But alsoBut also
Compiled language, few runtime dependencies
Produces binaries, that could be static with musl
Can interact easily with other languages via ABI and
bindings (Python, C/C++, JS...)
State of mind, hard at compile time, but safe at runtime
Somewhere challenging !

Ripgrep (rg)Ripgrep (rg)
An application written in RustAn application written in Rust
A grep enhanced
Compatible with standard grep
Search speed is really
impressive
Look also at fd, exa, lsd...

And a cute mascot !And a cute mascot !

What it looks likeWhat it looks like
extern crate flate2;
use flate2::read::GzDecoder;
use std::fs::File;
use std::io::Read;
fn run() -> String {
let path = "ascii.txt.gz";
let mut contents = String::new();
let gz = File::open(path).unwrap(); // open and decompress file
let mut uncompress = GzDecoder::new(gz);
uncompress.read_to_string(&mut contents).unwrap();
contents // return implicitly contents
}
fn main() {
println!("Hello, world!");
let result = run(); // call run function
println!("{}", result); // display compress file content
}

Language featuresLanguage features
Static type system with local type
inference
Explicit mutability
Zero-cost abstractions
Runtime-independent concurrency safety
Errors are values
No null
Static automatic memory management
No garbage collection

Safety is achieved by mainly 3 conceptsSafety is achieved by mainly 3 concepts

MutabilityMutability
struct Bike {
speed: u32,
distance: u32,
brand: String,
}
fn main() {
let mybike = Bike {
speed: 25,
distance: 1508,
brand: "Liteville".to_string(),
};
mybike.speed = 30; //Reassign !!!
println!(
"Bike {}: speed={} distance={}",
mybike.brand, mybike.speed, mybike.distance
);
}

Mutability errorMutability error
error[E0594]: cannot assign to field `mybike.speed` of immutable binding
--> src/main.rs:14:5
|
8 | let mybike = Bike {
| ------ help: make this binding mutable: `mut mybike`
...
14 | mybike.speed = 30; //Reassign !!!
| ^^^^^^^^^^^^^^^^^ cannot mutably borrow field of immutable binding
error: aborting due to previous error
For more information about this error, try `rustc --explain E0594`.
error: Could not compile `immutability`.

Ownership & BorrowingOwnership & Borrowing
Every piece of data is uniquely owned
Ownership can be passed
When owned data reaches the end of a scope, it is
destroyed

OwnershipOwnership
fn main() {
let s1 = String::from("Hello, RUST ! 🦀");
let s2 = s1;
println!("{}", s1);
}

Ownership errorOwnership error
--> src/main.rs:3:9
|
3 | let s2 = s1;
|
= note: #[warn(unused_variables)] on by default
error[E0382]: borrow of moved value: `s1`
|
3 | let s2 = s1;
| -- value moved here
4 | println!("{}", s1);
| ^^ value borrowed here after move
|
= note: move occurs because `s1` has type
`std::string::String`, which does not implement the `Copy` trait
error: Could not compile `owned2`.

OwnershipOwnership
fn main() {
let s = String::from("Hello, RUST ! 🦀");
display(s);
display(s); // Already owned !
}
fn display(some_string: String) {
println!("{}", some_string);
}

Ownership & BorrowingOwnership & Borrowing
Access can be borrowed (mutable and
immutable)
You can borrow mutably once
Or multiple times immutably
Exclusive: mutable or immutable, never both

BorrowingBorrowing
fn main() {
let s = String::from("Hello, RUST ! 🦀");
display(&s);
display(&s);
}
fn display(some_string: &String) {
println!("{}", some_string);
}
Hello, RUST ! 🦀
Hello, RUST ! 🦀

Borrowing mutableBorrowing mutable
fn main() {
let s = String::from("Hello");
change(&s);
println!("{}", s);
}
fn change(some_string: &String) {
some_string.push_str(", RUST ! 🦀");
}

Borrowing mutable errorBorrowing mutable error
error[E0596]: cannot borrow immutable borrowed content `*some_string` as mutable
--> src/main.rs:9:5
|
8 | fn change(some_string: &String) {
| ------- use `&mut String` here to make mutable
9 | some_string.push_str(", RUST ! 🦀");
| ^^^^^^^^^^^ cannot borrow as mutable
error: Could not compile `borrow_mut`.

Borrowing mutable fixedBorrowing mutable fixed
fn main() {
let mut s = String::from("Hello");
change(&mut s);
println!("{}", s);
}
fn change(some_string: &mut String) {
some_string.push_str(", RUST ! 🦀");
}
Hello, RUST ! 🦀

References validity checksReferences validity checks
#[derive(Debug)]
struct Person<'a> {
first_name: &'a str,
last_name: &'a str,
age: &'a i32,
phone: Vec<&'a str>,
}
fn return_reference<'a>() -> Person<'a> {
let age = 25;
Person {
first_name: "John",
last_name: "Doe",
age: &age,
phone: vec!["123-123", "456-456"],
}
}
fn main() {
let person = return_reference();
println!("{:?}", person);
}

References validity checks errorReferences validity checks error
error[E0597]: `age` does not live long enough
|
15 | age: &age,
| ^^^ borrowed value does not live long enough
...
18 | }
| - borrowed value only lives until here
|
note: borrowed value must be valid for the lifetime 'a as defined on the function
body at 9:1...
--> src/main.rs:9:1
|
9 | fn return_reference<'a>() -> Person<'a> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Concurrency without fearConcurrency without fear

Concurrency without fear errorConcurrency without fear error
Rust type system allows no data racesRust type system allows no data races
error[E0596]: cannot borrow `words` as mutable, as it is a captured variable
in a `Fn` closure
|
19 | .for_each(|arg| tally_words(arg.to_string(), &mut words).unwrap());
| ^^^^^^^^^^ cannot borrow
as mutable
|
help: consider changing this to accept closures that implement `FnMut`
|
19 | .for_each(|arg| tally_words(arg.to_string(), &mut words).unwrap());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

High level abstractionHigh level abstraction
Generics and TraitsGenerics and Traits
Define shared behavior
Define behavior based on types
Define behavior from various types with trait
bounds

Unsafe RustUnsafe Rust
Allow to disengage some safety features
Use at your own risk !
Crates using unsafe code can be audited with cargo-
geiger

A modern languageA modern language
with builtin code quality standardswith builtin code quality standards
Documentation embedded into code
Unit tests
Integration tests
Great documentation (books and std
lib)

A modern languageA modern language
with tools to be productivewith tools to be productive
Environment setup and update rustup
Package (crates) management cargo + plugin
Code formatting rustfmt
Compiler rustc
Efficient error messages
Potential solution
Linter clippy
Code completion racer
Help transition to 2018 edition rustfix
Editor integration (IntelliJ, Vs code, Vim,
Emacs...)

Opinionated for productivityOpinionated for productivity
Avoiding bikesheddingAvoiding bikeshedding
Crates have a defined filesystem structure
Modules & exports based on file location (like Python)
But with control over public / private exports (like
ES6)
Batteries included, but replaceable
Procedural macros for DSLs (eg: JSON, CSS...)
Custom compile-time extensions with build scripts
Cargo extensions with cargo-foo binary crates

Interesting cratesInteresting crates
That extend the std libThat extend the std lib
Date and time management chrono
Parallel iteration rayon
HTTP client reqwest
Command line parsing clap, docopt,
structopt
Logging log
Serialization serde
Regular expressions regex
...

Area of useArea of use
Command line tools
Web and network
services
Embedded device, IOT
WebAssembly
Games

Who is using Rust ?Who is using Rust ?
Mozilla, servo project
RedHat, stratis
project
Dropbox
Telenor
Chef

Ready at dawn
Chucklefish that published Stardew Valley and Starbound,
is using Rust in their new projects Wargroove and
Witchbrook to get safe concurrency and portability

Clevercloud, (Geoffroy Couprie)
nom, parser
Sozu, reverse proxy
Snips
ANSSI: RFC for secure application design in
Rust

Governance and communityGovernance and community
Rust is pragmaticRust is pragmatic
All features are driven by needs of real software
The language is evolved with user feedback
Consciously chooses familiar constructs
Picks good ideas from others
Doesn’t want to be the primary language at all
cost

Beloved language and communityBeloved language and community
Voted "Most loved language" on Stackoverflow 2018,
2017, 2016
Only 1/100 of survey respondents have issues with the
Rust community
Newcomers from all directions
https://insights.stackoverflow.com/survey/2018/#most-loved-dreaded-and-wantedhttps://insights.stackoverflow.com/survey/2018/#most-loved-dreaded-and-wanted

growthgrowth
https://8-p.info/visualizing-crates-io/https://8-p.info/visualizing-crates-io/
Crates.ioCrates.io

Help from the communityHelp from the community
Lots of books
IRC and Discord
channels
User forum
Youtube channel
Meetups

Beloved language and communityBeloved language and community
Experience from Mozilla to drive open projects
All major decisions, go to an open Request For
Comments process
Release every 6 weeks
3 channels: stable, beta and nightly
Medium time to merged PR for changes: 6 days!
More then 4/5 of contributions to the Rust language come
from outside Mozilla
The compiler has more then 2000 contributors

THANK YOUTHANK YOU
René Ribaud <rene.ribaud@cgi.com>
François Best
<contact@francoisbest.com>

Be pinched by a cRUSTacean to prevent programming errors !

More Related Content

What's hot (13)

Similar to Be pinched by a cRUSTacean to prevent programming errors ! (20)

Recently uploaded (20)

Be pinched by a cRUSTacean to prevent programming errors !