Rust sans (trop) roter du sang — Touraine Tech 2023 — par Édouard Siha & Alexis Horgix Chotard

—
Rust sans (trop)
roter du sang
Rassurez-vous, tout va bien se passer.
19 janvier 2023

Rust sans (trop) roter du sang
Premiers mots…
Alexis « Horgix » Chotard
SRE chez
@Horgix
Horgix
Édouard Siha
Cloud-Native Dev chez
https://blog.wescale.fr/

1er
contact
01

—
01 Anatomie de Ferris
1er
contact
Paradigmes procédural,
fonctionnel,
concurrent
Programmation système
Compilé
Sûreté
Performance
Typage fort, statique

—
01 HTTP headers
1er
contact
use std::collections ::HashMap;
use reqwest::{blocking ::Response , Error};
use serde::Deserialize ;
#[derive(Deserialize , Debug)]
struct Headers {
headers: HashMap<String, String>,
}
fn main() {
let url: &str = "https://httpbin.org/headers" ;
let http_response : Result<Response , Error> = reqwest::blocking ::get(url);
match http_response {
Ok(response ) => {
let headers = response .json::<Headers>().unwrap();
println! ("Headers: {:?}", headers);
},
Err(_) => {println! ("Failed to call httpbin" );},
}
}
Petit programme qui :
- fait un appel HTTP synchrone
à httpbin,
- désérialise le résultat vers un
type approprié,
- aﬃche le résultat
… le tout de manière sûre (à une
exception volontaire près) et en
utilisant des bibliothèques usuelles
au passage.
Notre objectif : faire en sorte que
ce bout de code soit limpide pour
vous à la ﬁn de la conférence !

—
01 Cargo
1er
contact
L’outil intégré au langage pour… à peu près tout faire :
● Gestion des dépendances ;
● Cycle de de vie de développement ;
● Documentation ;
● Publication de bibliothèques ;
● Formatage automatique des ﬁchiers source ;
● etc.

Gestion de la
mémoire
02

—
02 Problématiques
Gestion de la mémoire
● Quelle quantité de mémoire allouer ?
● Comment initialiser la mémoire allouée ?
● Quand libérer la mémoire allouée ?
● Comment orchestrer les accès concurrents ?
● Comment faciliter la gestion ?

—
02 L’approche manuelle
Allocation Manuelle : fonctions malloc et compagnie
Libération Manuelle : fonction free
Initialisation Manuelle*
Contrôle de la
concurrence
Au besoin, manuellement (sémaphores, verrous, etc.)
Contrôle Maximal
Sûreté Minimale
Facilité Moyenne

—
02 L’approche déléguée
Allocation Déléguée : mot-clef new
Libération Déléguée : ramasse-miettes
Initialisation Valeurs par défaut*
Contrôle de la
concurrence
Au besoin, manuellement (sémaphores, verrous, etc.)
Contrôle Minimal
Sûreté Moyenne
Facilité Maximale

—
02 L’approche de Rust
Allocation Déléguée : sans mot-clé
Libération Systématique : à la perte de visibilité du possesseur
Initialisation Requise pour l’utilisation
Contrôle de la
concurrence
Systématique : intégrée au langage
Contrôle Maximal
Sûreté Maximale
Facilité Presque maximale

—
02 Possession et emprunt
🏠
👤 possède

—
🏠
👤
emprunte en
« lecture seule » 👥
possède

—
🏠
👤 possède
🛠
emprunte en
« écriture »

—
🏠
👤
emprunte en
« lecture seule » 👥
possède
🛠
emprunte en
« écriture »

—
🏠
👤 possède
👤

—
🏠
👤 possède
👤
« déplace » la propriété

—
🏠
👤 👤
possède

—
02 … par l’exemple
Explication live sur une animation vidéo de 5min36 !
Désolé, vous devrez attendre la diﬀusion
de l’enregistrement vidéo pour en proﬁter.
Stay tuned :
https://touraine.tech/
https://twitter.com/tourainetech

Les notions
indispensables
03

—
03 Pattern
matching
Les notions indispensables
let x = 1;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("anything else"),
}
Permet de s’assurer de ne jamais
oublier de cas. Pas d’oubli, même à
3h du matin ou après 3 pintes !

—
03 Type
Result
let parsing_result = "Hello".parse::<i32>();
match parsing_result {
Ok(i: i32) => println!("Yay, success: {}", i),
Err(_) => println!("Oh no, an error!"),
}
Gérer les cas d’erreur :
● Proprement,
● En étant sûr de ne pas
oublier de les gérer,
● Avec des types appropriés.
Result<i32, ParseIntError>

—
03 Type
Option
let talk_audience = Some("Tours");
match talk_audience {
Some(audience: &str) => println!("Hello {}", audience),
None => println!("Damn, no one is here :("),
}
Parce que des fois, on a une valeur
mais… des fois, on en a pas.
Adieu les nil pointers pour
représenter l’absence consciente et
volontaire de valeur !
Option<&str>

—
03 Raccourci n°1
?
let i: i32 = "Hello".parse::<i32>()?;
// Strictement équivalent à :
let i: i32 = match "Hello".parse::<i32>() {
Ok(val: i32) => val,
Err(err: ParseIntError) => return Err(From::from(err)),
};
L’opérateur ? permet de retourner
directement une erreur, laissant
ainsi la responsabilité à l’appelant
de la traiter ou de la remonter à
son tour.
Result<i32, ParseIntError>

—
03 Raccourci n°2
.unwrap()
let talk_audience: &str = Some("Tours").unwrap();
// Strictement équivalent à :
let talk_audience: &str = match Some("Tours") {
Some(audience: &str) => audience,
None => panic!("No talk_audience"),
};
« Si, si, je suis sûr, j’ai une valeur, j’ai
pas None, promis ! »
Extrait directement la valeur d’un
type Option ou panic s’il n’y en a
pas.
Attention, danger ! Option<&str>

—
03 Enums
Elles ont l’air banales… mais pas
tant que ça.
enum TalkKind {
Conference,
Meetup,
TouraineTech,
}

—
03 Struct
enum TalkKind {
Conference,
Meetup,
TouraineTech,
}
struct Talk {
title: String,
kind: TalkKind,
audience: Option<String>,
}
La base des structures de données
en Rust.

—
03 Struct
enum TalkKind {
Conference,
Meetup,
TouraineTech,
}
struct Talk {
title: String,
kind: TalkKind,
}
let talk = Talk {
title: "Rust sans (trop) roter du sang".to_string(),
kind: TalkKind::TouraineTech,
audience: Some("Tours".to_string()),
};
La base des structures de données
en Rust.

—
03 Traits
let talk = Talk {
};
println!("Talk info: {}", talk);
Essayons d’aﬃcher simplement les
infos de notre struct.

—
03 Traits
let talk = Talk {
};
Uh ?!

—
03 Traits
let talk = Talk {
};
Contrat d’un comportement.
Parfois appelé interface dans
d’autres langages.

—
03 Traits
use std::fmt::{Display, Formatter};
let talk = Talk {
};
impl Display for Talk {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.title)
}
}
Un bloc impl par implémentation
de trait. Possible d’implémenter
plusieurs traits pour un même
type.

—
03 Derive
let talk = Talk {
};
println!("Talk info: {:?}", talk);
Revenons à notre erreur…
Il y avait une deuxième option !

—
03 Derive
let talk = Talk {
};
Non, toujours pas…

—
03 Derive
struct Talk {
title: String,
kind: TalkKind,
}
let talk = Talk {
};
Non, toujours pas…

—
03 Derive
#[derive(Debug)]
struct Talk {
title: String,
kind: TalkKind,
}
let talk = Talk {
};
Implémentation automatique de
certains traits !

—
03 Résumé
#[derive(Debug)]
enum TalkKind {
Conference,
Meetup,
TouraineTech,
}
#[derive(Debug)]
struct Talk {
title: String,
kind: TalkKind,
}
let talk = Talk {
};
match talk.audience {
Some(audience) => {
println!("Yay! Thanks {}!", audience);
},
None => { println!("Too bad :(") },
}
let cool_lang = talk.title.find("Rust")?;
● Pattern Matching
● Type Result
○ … et ?
● Type Option
○ … et .unwrap()
● Enums
● Structs
● Traits
● Derive

Mise en œuvre
04

—
04 En direct !
Mise en œuvre
☁

—
04 En direct !
Mise en œuvre

—
04 Live démo
Mise en œuvre
Live coding de 14min !
Désolé, vous devrez attendre la diﬀusion
de l’enregistrement vidéo pour en proﬁter.
Stay tuned :
https://touraine.tech/
https://twitter.com/tourainetech

Les amis de
Ferris
05

—
05 Plein d’outils !
Les amis de Ferris
reqwest
On a toujours besoin d’un
client HTTP près de soi
clap
Bijou de construction
de CLI
clippy
Encore mieux que le linter
de base de Ferris
serde
Couteau suisse de la
(de)serialization
tokio
anyhow
warp
log
…

Conclusion
& Bonus
06

—
06 HTTP headers
Conclusion
use std::collections ::HashMap;
use reqwest::{blocking ::Response , Error};
use serde::Deserialize ;
#[derive(Deserialize , Debug)]
struct Headers {
headers: HashMap<String, String>,
}
fn main() {
let url: &str = "https://httpbin.org/headers" ;
let http_response : Result<Response , Error> = reqwest::blocking ::get(url);
match http_response {
Ok(response ) => {
let headers = response .json::<Headers>().unwrap();
println! ("Headers: {:?}", headers);
},
Err(_) => {println! ("Failed to call httpbin" );},
}
}
Normalement, vous devriez
désormais être à même de
comprendre globalement ce que
notre premier morceau de code fait
et comment il le fait.
Si vous êtes joueur ou joueuse,
trouvez pourquoi nous mentionnions
“à une exception près” quant à la
sûreté de ce programme !

—
Conclusion
Pourquoi Rust maintenant
06
● La Rust Foundation
● 6 ans de “Most Loved Language” StackOverﬂow…
● L’engouement… que ça soit par les développeurs ou les entreprises
Source: Google Trends, 2010-2023, Mondialement

—
Bonus
Pour vous accompagner dans le voyage
06
https://doc.rust-lang.org/stable/book
● https://github.com/rust-lang/rustlings
● https://www.arewewebyet.org
● https://www.reddit.com/r/rust/
● … et de la pratique !

—
Bonus
Les objectifs de Rust
06
Les objectifs de Rust :
● Concevoir et implémenter un langage sûr,
concurrent et orienté pratique
● Rust existe car les autres langages avec le même
niveau d’abstraction et de performance ne sont
pas satisfaisants. En particulier :
○ Trop peu d’attention est donnée à la sûreté
○ Ils ont un faible niveau de support des calculs
en parallèle
○ Il y a un clair manque de commodités
pratiques
○ Ils oﬀrent un contrôle limité sur les
ressources
● Rust existe comme une alternative qui fournit à la
fois du code performant et un niveau
d’abstraction confortable, tout en améliorant les
choses sur les 4 précédents points.
Les non-objectifs de Rust :
● Nous n’employons pas de technologie
particulièrement à la pointe.
● Les techniques éprouvées fonctionnent bien.
● Nous ne plaçons pas l’expressivité, le
minimalisme ou l’élégance avant les autres
objectifs.
● Il s’agit d’objectifs louables, mais secondaires.
● Nous ne visons pas la parité avec C++ ou
n’importe quel autre langage. Rust devrait
couvrir le dénominateur commun.
● Nous ne voulons pas être 100% statique, sûr ou
réﬂectif. Pas de dogme.
● Nous n’exigeons pas que Rust puisse tourner
sur « toutes les plateformes existantes »,
seulement sur les plus courantes et sans
bidouille.

Merci ! Derniers mots…
Votre avis compte pour nous !
Alexis « Horgix » Chotard
SRE chez
@Horgix
Horgix
Édouard Siha
Cloud-Native Dev chez
https://blog.wescale.fr/
Il fallait être là
en live :)

— Crédits images
99
Colophon
● Logo Rust : Rust Foundation
https://foundation.rust-lang.org/
● Ferris, la mascotte non oﬃcielle : Karen Rustad Tölva
https://rustacean.net/
● Logo Cargo : Rust Foundation
https://foundation.rust-lang.org/
● Puces mémoire : Laura Ockel
https://unsplash.com/photos/qOx9KsvpqcM
● Logo C : Domaine public
https://commons.wikimedia.org/wiki/File:C_Programming_Language.svg
● Logo Java : Oracle
https://upload.wikimedia.org/wikipedia/fr/thumb/2/2e/Java_Logo.svg/550px-Java_Logo.svg.png
● Clavier : Sergi Kabrera
https://unsplash.com/photos/2xU7rYxsTiM

Rust sans (trop) roter du sang — Touraine Tech 2023 — par Édouard Siha & Alexis Horgix Chotard

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (15)

Similaire à Rust sans (trop) roter du sang — Touraine Tech 2023 — par Édouard Siha & Alexis Horgix Chotard

Similaire à Rust sans (trop) roter du sang — Touraine Tech 2023 — par Édouard Siha & Alexis Horgix Chotard (20)

Rust sans (trop) roter du sang — Touraine Tech 2023 — par Édouard Siha & Alexis Horgix Chotard