diff --git a/algorithmique/cours/modularite.txt b/algorithmique/cours/modularite.txt
index a729448..276d12d 100644
--- a/algorithmique/cours/modularite.txt
+++ b/algorithmique/cours/modularite.txt
@@ -1,4 +1,4 @@
-Introduction à la modularité
+La programmation structurée
 =============================
 
 Un langage de programmation doit permettre la programmation structurée.
@@ -21,54 +21,8 @@ Si on ne prend pas garde au bon découpage des programmes en modules indépendan
 on se retrouve rapidement débordé par un grand nombre de variables,
 et il devient quasiment impossible de réaliser un programme correct.
 
-La modularité
-~~~~~~~~~~~~~
-
-Les données et les traitements sont regroupés au sein d'une même entité à deux
-facettes : d'un côté le code proprement dit, de l'autre son interface. La
-communication entre modules s'effectue via leur interface. La description d'un
-type peut être masquée en n'apparaissant pas dans l'interface du module. Ces
-types de données abstraits facilitent les modifications d'implantation à
-l'intérieur d'un module sans affecter les autres modules qui s'en servent. De
-plus, les modules peuvent être paramétrés par d'autres modules augmentant
-ainsi leur réutilisabilité.
-
-Le paradigme objet
-~~~~~~~~~~~~~~~~~~
-
-Les descriptions des traitements et des données sont regroupées dans des
-entités appelées **classes**; un objet est une instance (valeur) d'une classe.
-La communication entre objets est réalisée par envoi de message, l'objet
-receveur détermine à l'exécution (liaison retardée) le traitement
-correspondant au message. En cela, la programmation objet est dirigée par
-les données. La structuration d'un programme provient des relations entre
-classes, en particulier l'héritage permet de définir une classe par extension
-d'une autre.
-
-En programmation objet, un **programme** est une collection d’objets qui communiquent
-entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
-
-Comparaison entre les deux paradigmes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Il y a dualité entre ces deux modèles.
-
-- On ne peut pas augmenter les composants d'un type dans un module (pas
-  d'extensibilité des données), mais on peut ajouter de nouveaux traitements
-  (extensibilité des traitements) sur ces données.
-
-- En objet, on peut ajouter des sous-classes à une classe (extensibilité des
-  données) pour traiter des nouveaux cas, mais on ne peut pas ajouter de nouveaux
-  traitements visibles de la classe ancêtre (pas d'extensibilité des traitements).
-
-**La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
-traitements et les données.**
-
-Sûreté d'exécution
---------------------
-
 La programmation raisonnée
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------
 
 Un **programme** est le codage d'un algorithme dans un langage de programmation.
 La programmation consiste à modéliser un problème du monde réel sous une forme
@@ -198,3 +152,49 @@ et l'implémentation effective de l'algorithme
                  config_save_values(c, MODNAME)
                  return True
          return False
+
+Les deux grands paradigmes
+---------------------------
+
+La modularité
+~~~~~~~~~~~~~~
+
+Les données et les traitements sont regroupés au sein d'une même entité à deux
+facettes : d'un côté le code proprement dit, de l'autre son interface. La
+communication entre modules s'effectue via leur interface. La description d'un
+type peut être masquée en n'apparaissant pas dans l'interface du module. Ces
+types de données abstraits facilitent les modifications d'implantation à
+l'intérieur d'un module sans affecter les autres modules qui s'en servent. De
+plus, les modules peuvent être paramétrés par d'autres modules augmentant
+ainsi leur réutilisabilité.
+
+Le paradigme objet
+~~~~~~~~~~~~~~~~~~
+
+Les descriptions des traitements et des données sont regroupées dans des
+entités appelées **classes**; un objet est une instance (valeur) d'une classe.
+La communication entre objets est réalisée par envoi de message, l'objet
+receveur détermine à l'exécution (liaison retardée) le traitement
+correspondant au message. En cela, la programmation objet est dirigée par
+les données. La structuration d'un programme provient des relations entre
+classes, en particulier l'héritage permet de définir une classe par extension
+d'une autre.
+
+En programmation objet, un **programme** est une collection d’objets qui communiquent
+entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
+
+Comparaison entre les deux paradigmes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Il y a dualité entre ces deux modèles.
+
+- On ne peut pas augmenter les composants d'un type dans un module (pas
+  d'extensibilité des données), mais on peut ajouter de nouveaux traitements
+  (extensibilité des traitements) sur ces données.
+
+- En objet, on peut ajouter des sous-classes à une classe (extensibilité des
+  données) pour traiter des nouveaux cas, mais on ne peut pas ajouter de nouveaux
+  traitements visibles de la classe ancêtre (pas d'extensibilité des traitements).
+
+**La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
+traitements et les données.**
diff --git a/algorithmique/cours/modules.txt b/algorithmique/cours/modules.txt
index ba5d0f7..53f30da 100644
--- a/algorithmique/cours/modules.txt
+++ b/algorithmique/cours/modules.txt
@@ -1,5 +1,5 @@
-Les modules
-============
+La programmation modulaire
+===========================
 
 Il s'agit de décomposer un grand programme en
 morceaux (**modules**) connectés entre eux par des **interfaces** bien
@@ -240,3 +240,72 @@ obtenir un nouveau module :
 .. code-block:: ocaml
 
     module M = F (Titi) (Toto)
+
+
+Signatures, type abstrait et langage de modules
+=================================================
+
+Contrainte de type par signature
+------------------------------------
+
+::
+
+      module M =
+        struct
+          type t = int * int * int ;;
+          let make d m y = d, m, y ;;
+        end ;;
+
+      let d = M.make 8 5 8 ;;
+
+      module type S =
+        sig
+          type t ;;
+          val make : int -> int -> int -> t ;;
+        end ;;
+
+      module MS  = (M:S) ;;
+
+      MS.make 5 1 2 ;;
+
+Type et signature
+------------------
+
+::
+
+      # module type A = sig
+        val a: int -> int
+        end ;;
+      module type A = sig val a : int -> int end
+      # module B = struct
+        let a x = x + 1 ;;
+        end;;
+      module B : sig val a : int -> int end
+      # module C = (B:A) ;;
+      module C : A
+
+      # C.a 2 ;;
+      - : int = 3
+      #
+
+Module auquel on impose une signature
+-----------------------------------------
+
+
+::
+
+      module  type DATE = sig
+            type t
+            val make: int -> t
+            val get_year: t -> int
+            val get_month: t -> int
+            end ;;
+
+      module MR = struct
+          type t = int * int
+          let make x y = (x, y)
+          let get_month (x, y) = x
+          let get_year (x, y) = y
+      end ;;
+
+      module date = (MR:DATE) ;;
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index 51dbde1..0878939 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -352,6 +352,17 @@ Il est possible de communiquer de la manière suivante avec un programme :
 - lire (du texte, un nombre...)
 - interagir avec les prompts
 
+
+.. code-block:: ocaml
+
+    let x = read_int () in
+        let signe =
+            if x >= 0
+            then " positif "
+            else " négatif " in
+                print_string signe
+
+
 .. ifconfig:: exercice
 
     **Exercice** : écrire un algorithme qui demande le prénom d'une personne
diff --git a/algorithmique/markup.txt b/algorithmique/markup.txt
new file mode 100644
index 0000000..fc60a06
--- /dev/null
+++ b/algorithmique/markup.txt
@@ -0,0 +1,102 @@
+markup
+========
+
+exercices
+---------
+
+
+.. ifconfig:: exercice
+
+    **Exercice** : 
+
+.. ifconfig:: correction
+
+    **Correction** :
+
+
+sphinx
+-----------
+
+.. function:: spam(eggs)
+                 ham(eggs)
+
+      Spam or ham the foo.
+
+The function :func:`spam` does a similar thing
+
+
+http://www.sphinx-doc.org/en/stable/markup/code.html
+
+http://www.sphinx-doc.org/en/stable/domains.html
+
+latex
+--------------
+
+s'il faut mettre du latex :
+
+https://www.jujens.eu/posts/2014/Aug/13/rapport-rst-sphinx/
+
+(pour le preamble)
+
+
+.. role:: latex(raw)
+   :format: latex
+
+----
+
+sudo apt-get install texlive-full
+
+
+You need to remove
+
+\usepackage{algorithmicx}
+
+and use the following in your preamble:
+
+\usepackage{algorithm}% http://ctan.org/pkg/algorithms
+\usepackage{algpseudocode}% http://ctan.org/pkg/algorithmicx
+
+
+.. raw:: latex
+
+   \begin{algorithm}
+   \caption{My algorithm}\label{euclid}
+   \begin{algorithmic}[1]
+   \Procedure{MyProcedure}{}
+   \State $\textit{stringlen} \gets \text{length of }\textit{string}$
+   \State $i \gets \textit{patlen}$
+   \BState \emph{top}:
+   \If {$i > \textit{stringlen}$} \Return false
+   \EndIf
+   \State $j \gets \textit{patlen}$
+   \BState \emph{loop}:
+   \If {$\textit{string}(i) = \textit{path}(j)$}
+   \State $j \gets j-1$.
+   \State $i \gets i-1$.
+   \State \textbf{goto} \emph{loop}.
+   \State \textbf{close};
+   \EndIf
+   \State $i \gets
+   i+\max(\textit{delta}_1(\textit{string}(i)),\textit{delta}_2(j))$.
+   \State \textbf{goto} \emph{top}.
+   \EndProcedure
+   \end{algorithmic}
+   \end{algorithm}
+
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Euclid's algorithm}\label{euclid}
+    \begin{algorithmic}[1]
+    \Procedure{Euclid}{$a,b$}\Comment{The g.c.d. of a and b}
+       \State $r\gets a\bmod b$
+       \While{$r\not=0$}\Comment{We have the answer if r is 0}
+          \State $a\gets b$
+          \State $b\gets r$
+          \State $r\gets a\bmod b$
+       \EndWhile\label{euclidendwhile}
+       \State \textbf{return} $b$\Comment{The gcd is b}
+    \EndProcedure
+    \end{algorithmic}
+    \end{algorithm}