diff --git a/essential_rust.tex b/essential_rust.tex
index 9f0e6abf9bb26a4cb62d9c1340d881d1e599ce30..ddef1639800de597cb4917f08b27234dcdf95d88 100644
--- a/essential_rust.tex
+++ b/essential_rust.tex
@@ -4,6 +4,7 @@
 \usepackage{enumitem}
 
 \usepackage{hyperref}
+\usepackage{cleveref}
 
 \usepackage{titlesec}
 \newcommand{\sectionbreak}{\clearpage}
@@ -37,48 +38,87 @@
 
 Rust est un langage de programmation système, compilé et multi-paradigme.
 \begin{itemize}
-  \item Langage de programmation système : très peu de fonctionnalités sont implémentés dans les binaires résultants du langage. Par exemple, il n'y a pas de ramasse-miettes ou d'allocateur automatique.
-  \item Langage compilé : il est obligatoire de transformer le code Rust via un compilateur pour pouvoir l'exécuter.
-  \item Langage multi-paradigme : Le langage prend beaucoup de concepts des langages concurrents, orientés objets et fonctionnel.
+    \item Langage compilé : le code source n'est pas exécutable tel quel, il faut d'abord le
+        transformer avec un compilateur.
+    \item Langage de programmation système : très peu de fonctionnalités sont implémentés dans
+        les binaires résultants du langage.
+        en général il ne se passe rien qui n'ait été explicitement demandé dans le code source.
+        Par exemple, il n'y a pas de ramasse-miettes ou d'allocateur automatique.
+    \item Langage multi-paradigme : le langage prend beaucoup de concepts des langages
+        concurrents, orientés objets et fonctionnel.\\
+        Par exemple :
+        \begin{itemize}
+            \item tout comme dans les langages orientés objets, la plupart du code se fait
+                en définissant des structures de données et des méthodes qui opèrent dessus.
+            \item tout comme dans les langages fonctionnels, tout est une expression
+                (voir \Cref{expressionsEverywhere})
+        \end{itemize}
 \end{itemize}
 
 
-L'objectif du Rust est d'atteindre trois objectifs : rapidité, sécurité, et concurrent.
+L'objectif du Rust est de ne sacrifier aucun des trois critères :
+rapidité, sécurité, et concurrence.
 
-Pour atteindre ces objectifs, la syntaxe de Rust est enrichie pour permettre au compilateur d'avoir l'ensemble des informations nécessaires.
+Pour ce faire, la syntaxe de Rust est enrichie pour permettre au compilateur
+d'avoir l'ensemble des informations nécessaires : il y aura souvent plus d'indications de types
+à écrire qu'en OCaml et plus d'opérations à rendre explicite (conversions de type,
+mutabilité, durées de vies) qu'en C/C++.
 
 
 \section{Environnement et outils}
 
-L'environnement de Rust se compose de beaucoup d'outils aidant le développement ainsi que le déploiement.
+L'environnement de Rust se compose de beaucoup d'outils aidant le développement ainsi
+que le déploiement.
 
 \subsection{\texttt{rustc} : compilateur Rust}
 
 Le compilateur Rust fonctionne principalement comme les autres compilateurs.
-Cependant, il est rare de l'utiliser directement.
+Cependant, il est rare de l'utiliser directement car \texttt{cargo} permet
+souvent de s'affranchir d'invoquer explicitement \texttt{rustc}.
+
+Voici un exemple de compilation d'un fichier nommé \texttt{source.rs} vers
+un binaire exécutable nommé \texttt{bin} en activant les optimisations :
+\texttt{rustc source.rs -o bin -O}
 
 
 \subsection{\texttt{cargo} : outil de gestion de projet}
 
-\texttt{cargo} est un outil de build, comme peut l'être \texttt{make}, mais comporte beaucoup plus de fonctionnalités :
+\texttt{cargo} est un outil de build, comme peut l'être \texttt{make}, mais comporte
+beaucoup plus de fonctionnalités :
 \begin{itemize}
-  \item Téléchargement automatique des dépendances externes
-  \item Compilation pour le développement et pour la production
-  \item Création de la documentation
-  \item Lancement des tests
+  \item téléchargement automatique des dépendances externes
+  \item compilation pour le développement et pour la production
+      (le premier est plus rapide à compiler mais est moins rapide à l'exécution)
+  \item création de la documentation
+  \item lancement des tests
+  \item appel de commandes externes
 \end{itemize}
 
 
 \subsection{\texttt{clippy} : linter Rust}
 
-Le linter permet d'optimiser le code en utilisant par exemple des fonctionnalités de Rust.
+Le linter lit le code et recherche des patterns qui sont...
+\begin{itemize}
+    \item ...souvent des indices d'un bug\\
+        (variable inutilisée, conversion de type inutile, code inaccessible, ...)
+    \item ...considérés comme de mauvaises pratiques\\
+        (trop de variables à une lettre, ...)
+    \item ...connus pour être moins performants qu'une alternative\\
+        (copies profondes inutiles, pointeurs inutiles, structures de données peu
+        efficaces en mémoire, ...)
+\end{itemize}
+
+On peut lancer un linter basique avec \texttt{cargo check}, et \texttt{cargo clippy} en
+est la version plus poussée.
 
-Il peut être inclus directement dans le compilateur.
+On trouve à l'addresse \href{https://rust-lang.github.io/rust-clippy/master/index.html}{https://rust-lang.github.io/rust-clippy/master/index.html}
+une liste exhaustive des vérifications de \texttt{clippy} (pas toutes activées par défaut),
+avec des explications de pourquoi le pattern est dangereux ou considéré mauvais.
 
 
-\subsection{\texttt{rls} : language Server Protocol}
+\subsection{\texttt{rls} : Language Server Protocol}
 
-L'ensemble des IDE migrent vers le protocole Open-Source de Microsoft : Lang Server Protocol.
+L'ensemble des IDE migrent vers le protocole Open-Source de Microsoft : Language Server Protocol.
 
 Ce protocole permet d'avoir les fonctionnalités principales d'un IDE (auto-complétion, saut vers les définitions...) par le biais d'un serveur propre au langage.
 
@@ -87,6 +127,8 @@ Ce protocole permet d'avoir les fonctionnalités principales d'un IDE (auto-comp
 
 Formatage du code afin que tout le monde puisse lire, écrire, et maintenir aisément du code.
 
+Il est la plupart du temps invoqué par \texttt{cargo fmt}.
+
 
 \section{Apprendre le Rust}
 
@@ -97,6 +139,17 @@ Il existe plusieurs sources d'informations pour apprendre le Rust :
   \item \href{https://doc.rust-lang.org/stable/rust-by-example/}{Rust by example} : apprendre par de nombreux exemples de cas d'utilisations
 \end{itemize}
 
+Quelques autres liens utiles :
+\begin{itemize}
+    \item \href{https://play.rust-lang.org/}{Playground} : pour faire des tests rapides
+        dans le navigateur ou regarder l'assembleur généré
+    \item \href{https://this-week-in-rust.org/}{This Week in Rust} : newsletter officielle
+    \item \href{https://github.com/rust-lang/rust/}{github:rust} : le code source intégral de
+        \texttt{rustc} et de la librairie standard
+    \item \href{https://crates.io}{Crates} : le dépôt de paquets officiel depuis lequel sont
+        téléchargées les dépendances
+    \item \href{https://docs.rs/}{Docs} : la documentation officielle de tous les paquets
+\end{itemize}
 
 
 \section{Premiers programmes : découverte du Rust}