diff --git a/Makefile b/Makefile
index 0ecf66ac6acbfff02c03bbdb47dbc5667a29118f..78b7f725c7fa7501051bca0063774ab61ec8ed89 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 REVEALOPRIONS = -t revealjs
 REVEALOPRIONS += --template ./default.revealjs
-# REVEALOPRIONS += -V theme=moon 
-REVEALOPRIONS += -V center=true
+REVEALOPRIONS += -V theme=simple
+# REVEALOPRIONS += -V center=true
 REVEALOPRIONS += -V margin=0
 # REVEALOPRIONS += -V minScale=0.2
 # REVEALOPRIONS += -V maxScale=2.0
@@ -12,7 +12,7 @@ REVEALOPRIONS += -V include-after="<script src="js/playRust.js"></script> \
 								   <script src="js/em-artiste.js"></script> \
 								   <script src="reveal.js/plugin/highlight/highlight.js"></script>"
 REVEALOPRIONS += -V header-includes="<link rel="stylesheet" href="reveal.js/lib/css/zenburn.css" >\
-								     <link rel="stylesheet" href="reveal.js/css/theme/moon.css" id="theme">\
+								     <link rel="stylesheet" href="reveal.js/css/theme/simple.css" id="theme">\
 								     <link rel="stylesheet" href="css/console.css" id="theme">\
 								     <script src="jquery/dist/jquery.min.js"></script>"
 REVEALOPRIONS += --section-divs
@@ -22,16 +22,11 @@ REVEALOPRIONS += --slide-level=1
 # REVEALOPRIONS += --highlight-style espresso
 # REVEALOPRIONS += --self-contained
 
-SVG=$(wildcard figs/*.svg)
-PNG=$(SVG:%.svg=%.png)
 MD=$(wildcard *.md)
 HTML=$(MD:%.md=%.html)
 
 
-all: $(PNG) $(HTML)
-
-figs/%.png: figs/%.svg
-	convert \-flatten $< $@
+all: $(HTML)
 
 %.html: %.md Makefile
 	pandoc -s $(REVEALOPRIONS) -o $@ $<
diff --git a/index.md b/index.md
index 690dc6499599a4d93a10c9838d8c84bad7f10377..1834deafaa1603d08f6f3aa3b9f3c6ce4ff241bf 100644
--- a/index.md
+++ b/index.md
@@ -16,6 +16,11 @@ sansfont: Sans Serif
 - [Types](types.html).
 - [Structures de contrôle](control.html).
 
+## Deuxième séance
+
+- [Types avancés](types_avances.html).
+- [Organisation du code](modules.html)
+
 ## Troisième séance
 
 - [Fonctions](fonctions.html).
@@ -23,5 +28,4 @@ sansfont: Sans Serif
 
 ## Quatrième séance
 
-- [Types avancés](types_avances.html).
 - [Commentaires](commentaires.html).
diff --git a/intro.md b/intro.md
index 2d94e3de6d83aa69a91228710d7620ceb74dc4a1..8a1ed09831e1a5fe9cf5a970e9d7983b7357e840 100644
--- a/intro.md
+++ b/intro.md
@@ -63,7 +63,7 @@ Contient certaines iformations qui peuvent être pratiques.
 
 ## Une mascotte super mignonne
 
-![Ferris](figs/ferris.png){height=50%}
+![Ferris](figs/ferris.svg){height=50%}
 
 # Historique
 
@@ -75,8 +75,8 @@ Contient certaines iformations qui peuvent être pratiques.
 - Orientation vers la programmation système.
 - Première version stable (1.0) en 2015 (3 ans cette année).
 - La très grande majorité des fonctionnalités du langages ont été retirées.
-- Stabilisation de fonctionalités tous les 6 semaines.
-- Version stable actuelle 1.28. <!-- TODO UPDATE -->
+- Stabilisation de fonctionnalités tous les 6 semaines.
+- Version stable actuelle 1.29. <!-- TODO UPDATE -->
 
 ## Plus d'informations
 
@@ -134,7 +134,7 @@ Un compilateur très pointilleux.
 
 ## Rapidité
 
-- Les conditions de sécurité sont gérées *à la compilation* (pas de ĉoût à l'exécution).
+- Les conditions de sécurité sont gérées *à la compilation* (pas de coût à l'exécution).
 - Le compilateur est basé sur la LLVM.
 - Abstractions à coût nul.
 - On paie pour ce qu'on utilise seulement.
@@ -144,5 +144,5 @@ Un compilateur très pointilleux.
 - Le compilateur a des règles très strictes...
 - ... mais il est possible de contourner les règles.
 - Syntaxe spéciale pour autoriser les comportement potentiellement dangereux.
-- Un guide pour bien vivre dangereusement.
+- Un guide pour bien vivre dangereusement <https://doc.rust-lang.org/nomicon/>.
 
diff --git a/modules.md b/modules.md
new file mode 100644
index 0000000000000000000000000000000000000000..a1d7bf4bae904edc41458d8d866675daaebaa58d
--- /dev/null
+++ b/modules.md
@@ -0,0 +1,127 @@
+---
+title: Cours de programmation séquentielle
+subtitle: Modules
+author: Orestis Malaspinas
+<!-- date: 25 avril 2018 -->
+sansfont: Sans Serif
+---
+
+# Organisation du code
+
+- Au fur et à mesure du développement séparer son code devient important.
+- Il faut **modulariser** le code:
+	1. Écrire des foncitons.
+	2. Séparer le code en fichiers (modules).
+- Aide à organiser le code.
+- Aide à maintenir le code.
+- Permet de "cacher" le code à l'utilisateur (il n'utilisera que ce que vous voulez qu'il utilise).
+
+# Modules
+
+## Une libraire (`crate`{.rust})
+
+- On peut créer une libraire avec `cargo new malibrairie --lib`.
+- Ou alors en créant un fichier `lib.rs` "à côté" du `main.rs` (dans `src/`).
+- Pour accéder à ce qui se trouve dans la librairie on devra utiliser
+
+	```{.lang-rust}
+	extern crate ma_librairie;
+	```
+
+- Et appeler les fonctions, enums, ...
+
+	```{.lang-rust}
+	ma_librairie::ma_fct();
+	ma_librairie::Mon_enum;
+	```
+
+## La définition d'un module
+
+- Dans le fichier `lib.rs` on peut à présent créer un/deux/... modules contenant une fonction
+	```{.lang-rust}
+	mod mon_module { // on peut même insérer d'autres modules à l'intérieur
+		fn ma_fonction() {
+			unimplemented!(); // macro très pratique!
+		}
+	}
+
+	mod mon_autre_module {
+		fn ma_fonction() {
+			unimplemented!(); // macro très pratique!
+		}
+	}
+	```
+
+- Les fonctions `mon_module::ma_fonction()`{.lang-rust}, `mon_autre_module::ma_fonction()`{.lang-rust} auront une signification (et une fonctionalité différente).
+
+## Fichiers (1/2)
+
+- Avoir tous ses modules dans un fichier: pas pratique.
+- On *déclare* les modules dans `src/lib.rs`, on met le contenu dans `src/mon_module.rs`
+
+	```{.lang-rust}
+	mod mon_module;
+
+	mod mon_autre_module {
+		fn ma_fonction() {
+			unimplemented!(); // macro très pratique!
+		}
+	}
+	```
+
+- Équivalent à 
+
+	```{.lang-rust}
+	mod mon_module {
+		// contenu de src/mon_module.rs
+	}
+
+	mod mon_autre_module {
+		fn ma_fonction() {
+			unimplemented!(); // macro très pratique!
+		}
+	}
+	```
+
+## Fichiers (2/2)
+
+- On peut aller encore plus loin: `src/lib.rs`
+
+	```{.lang-rust}
+	mod mon_module {
+		fn ma_fonction() {
+			unimplemented!(); // macro très pratique!
+		}
+
+		mod mon_autre_module {
+			fn ma_fonction() {
+				unimplemented!(); // macro très pratique!
+			}
+		}
+	}
+
+	```
+
+- Peut devenir:
+	- `src/lib.rs`
+
+		```{.lang-rust}
+		mod mon_module;
+		```
+	- `src/mon_module/mod.rs`
+
+		```{.lang-rust}
+		fn ma_fonction() {
+			unimplemented!(); // macro très pratique!
+		}
+
+		mod mon_autre_module;
+		```
+
+	- `src/mon_module/mon_autre_module.rs`
+
+		```{.lang-rust}
+		fn ma_fonction() {
+			unimplemented!(); // macro très pratique!
+		}
+		```
diff --git a/ownership.md b/ownership.md
index 94d774ea602e58579ac4bc92e8412526f0f264e8..482a48f9a28e7ef312ce5b22bdb44da8663aac44 100644
--- a/ownership.md
+++ b/ownership.md
@@ -96,7 +96,7 @@ fn main()
 
 ## Allocation de mémoire (3/3)
 
-![](figs/mem_vec.png){height=70%}
+![](figs/mem_vec.svg){height=70%}
 
 - La représentation en mémoire du vecteur $\vec v = (1,2,3,4)$.
 - Sur le tas: 1 pointeur vers le tas, et 2 entiers (longueur et capacité).
@@ -162,7 +162,7 @@ fn main()
 - En ne faisant rien on a **deux** propriétaires des données.
 - Illégal: on invalide $y$.
 
-![](figs/mem_mv.png){height=70%}
+![](figs/mem_mv.svg){height=70%}
 
 ## Exception au `move`
 
@@ -189,7 +189,7 @@ fn main()
 
 - Lors du `move`{.lang-rust} on copie uniquement la variable, pas les données et le propriétaire des données **change**.
 - Lors de la copie on duplique la variable **et** les données.
-![](figs/mem_cp.png){height=70%}
+![](figs/mem_cp.svg){height=70%}
 - Pour effectuer une copie on utilise `.clone()`{.lang-rust}.
 
 ## Quand interviennent les `move`{.lang-rust}?
@@ -268,7 +268,7 @@ fn main()
 - Si `y` est une variable, `&y`est la référence vers la variable (le pointeur vers cette variable).
 - La référence permet **l'emprunt** de données **sans** en prendre la **propriété**.
 
-![](figs/mem_ref_vec.png){height=70%}
+![](figs/mem_ref_vec.svg){height=70%}
 
 ## Exemple 1
 
diff --git a/types_avances.md b/types_avances.md
index c6017e343945eebc68803a438a57e13aadfcfb56..3021123235d175f8cfb70dc57a8d8efdf356860a 100644
--- a/types_avances.md
+++ b/types_avances.md
@@ -283,5 +283,34 @@ afin de décider d'une action à effectuer.
     }
     </code></pre>
 
+## Options
+
+- Un type énuméré particulièrement utile est le type `Option`{.rust
+.}
+```{.lang-rust}
+enum Option<T> { // <T> est une notation pour un type générique
+    Some(T),
+    None,
+}
+```
+- Type utilisé lorsque une valeur peut être "quelque chose" ou "rien".
+- Exmple: la division
 
-
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let num = 1;
+    let denum = 4;
+
+    let div = 
+        if denum == 0 {
+            None
+        } else {
+            Some(num / denum)
+        };
+
+    match div {
+        Some(d) => println!("{} divisé par {} donne {}", num, denum, d),
+        None => println!("Cette division n'existe pas."),
+    }
+}
+</code></pre>