diff --git a/02_introduction_async.md b/02_introduction_async.md
index a0497727f38c1b714e66e50b0f933935633cb69f..ff9b47703d9678d7ce0d4746f9d74181248dbb61 100644
--- a/02_introduction_async.md
+++ b/02_introduction_async.md
@@ -51,7 +51,7 @@ fn fib(n: u64) -> u64 {
     if n == 0 || n == 1 {
         n
     } else {
-        fin(n - 1) + fib(n - 2)
+        fib(n - 1) + fib(n - 2)
     }
 }
 ```
@@ -115,7 +115,7 @@ PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 
 ### Moralité
 
-* Le nombre de tâches a pas dramatiquement évolué....
+* Le nombre de tâches n'a pas dramatiquement évolué....
 * Malgré les 10 threads utilisés pour calculer les coefficients de Fibonacci
 
 . . .
@@ -134,7 +134,7 @@ PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 * Depuis 2 Threads
 * Incrémenter une variable partagée par les threads
 * Accès concurrent => Besoin de vérouiller la variable
-* Mais le modèle mémoire de Rust ne devrait pas permettre la modification d'une variable de deux endroits distintcs...
+* Mais le modèle mémoire de Rust ne devrait pas permettre la modification d'une variable de deux endroits distincts...
 * Alors comment faire?
 
 ## Mutex et Arc
@@ -245,7 +245,7 @@ async fn main() -> Result<(), Error> {
 ```
 
 * On fait les requêtes,
-* On attend que chacune des requêtes soient terminées
+* On attend que chacune des requêtes soit terminées
 * Gain?
 * Les différentes tâches sont exécutées "synchrones" (dans l'ordre)
 
@@ -281,7 +281,7 @@ async fn main() -> Result<(), Error> {
 
 . . .
 
-* L'OS gère les ressources affectées au différents programmes
+* L'OS gère les ressources affectées aux différents programmes
 * L'OS est responsable de démarrer, mettre en pause, arrêter les tâches
 * Permet d'avoir un clavier, souris, etc. qui fonctionnent "en même temps"
 * Tout cela est géré par l'ordonnanceur (scheduler)
@@ -299,7 +299,7 @@ async fn main() -> Result<(), Error> {
 
 ### Processus
 
-* Abstraction offert par l'OS et exécuté sur le CPU
+* Abstraction offerte par l'OS et exécuté sur le CPU
 * Une séquence d'instructions qui permettent d'effectuer des actions
 * Peut être créé par un autre processus
 * Possède un identifiant unique (assigné par l'OS)
@@ -308,7 +308,7 @@ async fn main() -> Result<(), Error> {
 
 . . .
 
-### Threads sytème
+### Threads système
 
 * Plus petit fil d'exécution d'un programme *séquentiel*
 * **Partage** l'espace mémoire avec les autres threads d'un processus
@@ -321,7 +321,7 @@ async fn main() -> Result<(), Error> {
 
 * La concurrence c'est **gérer** plusieurs actions en même temps
 * Le parallélisme c'est **exécuter** plusieurs actions en même temps
-* Une **tâche** est un suite d'opérations qui requièrent des **ressources** (CPU, mémoire, ...)
+* Une **tâche** est une suite d'opérations qui requièrent des **ressources** (CPU, mémoire, ...)
 
 ### Concurrence
 
diff --git a/07_stackless_coroutines.md b/07_stackless_coroutines.md
index 6c24b86bb0d94506e4af0d79c7ba8c1e251126c7..c617850b9d0a8c94a1956f80991680ade97c93d1 100644
--- a/07_stackless_coroutines.md
+++ b/07_stackless_coroutines.md
@@ -205,7 +205,7 @@ impl Http {
 
 ```rust
 struct HttpGetFuture {
-    // Option since we will not conect upon creation
+    // Option since we will not connect upon creation
     stream: Option<mio::net::TcpStream>,
     // buffer to read from the TcpStream
     buffer: Vec<u8>,
@@ -291,7 +291,7 @@ impl Future for HttpGetFuture {
 
 * Trois états différents
     1. `stream == None`  => `NotStarted`
-    2. `stream == Some() && read == Err(WuldBlock)` => `Pending`
+    2. `stream == Some() && read == Err(WouldBlock)` => `Pending`
     3. `stream == Some() && read == Ok(0)` => `Resolved`
 * Pas de modélisation explicite ici