added beginning of concurrency

presentation/codes/concurrent/Cargo.toml

+[package]
+name = "concurrent"
+version = "0.1.0"
+authors = ["Orestis Malaspinas <orestis.malaspinas@hesge.ch>"]
+edition = "2018"
+
+[dependencies]

presentation/codes/concurrent/src/main.rs

+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());
+
+}

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