diff --git a/presentation/codes/concurrent/Cargo.toml b/presentation/codes/concurrent/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d61af3ba9cfd528e27fa4af95ecc3066b9dcf70d
--- /dev/null
+++ b/presentation/codes/concurrent/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "concurrent"
+version = "0.1.0"
+authors = ["Orestis Malaspinas <orestis.malaspinas@hesge.ch>"]
+edition = "2018"
+
+[dependencies]
diff --git a/presentation/codes/concurrent/src/main.rs b/presentation/codes/concurrent/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..611c6e920954244e7ff297d51ac6a9a5387b127b
--- /dev/null
+++ b/presentation/codes/concurrent/src/main.rs
@@ -0,0 +1,17 @@
+use std::thread;
+
+fn main() {
+
+    let loc = thread::spawn( || {
+        "world"
+    });
+    println!("Hello {}!", loc.join().unwrap());
+
+    let mut v = Vec::new();
+    let loc = thread::spawn(move || {
+        v.push(1);
+        v
+    });
+    println!("{:?}", loc.join().unwrap());
+
+}
diff --git a/presentation/intro.md b/presentation/intro.md
index ae7cd1f56d7a2fa8effb89ec4dbdba60dd145d26..a80fa75108bbd40751790e1e869d5ae05867dde4 100644
--- a/presentation/intro.md
+++ b/presentation/intro.md
@@ -180,7 +180,7 @@ Ce qui se passe en mémoire:
 
 ## En pratique (3/3)
 
-En C++ une sytaxe similaire a un effet complètement différent
+En C++ une syntaxe similaire a un effet complètement différent
 
 ```
 void do_something(notebook: vector<string>) {
@@ -324,7 +324,7 @@ fn main() {
 
 ![](figs/mem_vec_mut_borrowing.svg){#fig:mem_vec_borrowing width=70%}
 
-La référence est **vérouillée** personne d'autre ne peut modifier ou lire les données.
+La référence est **verrouillée** personne d'autre ne peut modifier ou lire les données.
 
 ## En pratique (2/2)
 
@@ -357,9 +357,21 @@ fn main() {
 
 ## Les deux lois de l'emprunt
 
-1. On peut avoir autant de références **immutables** qu'on le shoutaire sur des données.
+1. On peut avoir autant de références **immutables** qu'on le souhaite sur des données.
 2. On ne peut avoir **une seule** référence mutable sur des données.
 
+## Les lois de la propriété et de l'emprunt
+
+Garantissent (presque toujours):
+
+- Le *aliasing* et la *modification de données* en même temps.
+- Le *double-free*
+- Le *use-after-free*,
+
+. . .
+
+- Donc: pas de *seg-faults.
+
 # `Unsafe` Rust
 
 ## Toute règle est faite pour être contournée
@@ -369,7 +381,24 @@ fn main() {
 - En bon Rust ils doivent être rares (4% du code de `rustc`).
 - Exemple : `raw pointer`
 
+# Fearless concurrency
+
+## Data race
+
+Les "data-race" surviennent quand:
+
+1. Partage de données.
+2. Mutation.
+3. Pas d'ordre d'exécution.
+
+. . .
+
+Le partage des données et la mutation est incompatible en Rust.
+
+## Rust prévient à la compilation
 
+- Les accès concurrents.
+- 
 
 # And many more