diff --git a/algorithmique/abstract.txt b/algorithmique/abstract.txt
deleted file mode 100644
index 52d472c..0000000
--- a/algorithmique/abstract.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-Initiation à l'algorithmique et présentation de la programmation
-================================================================
-
-**Présentation du cours**
-
-- L'accent est mis sur l'approche **algorithmique scientifique**, dite algorithmique
-  algébrique. L'algorithmique est un sous-domaine de l'algèbre et des
-  approches modulaires (arithmétique modulaire...)
-
-- Le point de vue mathématique étant assez exigeant, aucun formalisme fort de
-  l'algorithmique mathématique ne sera présenté. Aucun symbole mathématique donc, et
-  seulement du pseudo-code.
-  L'approche mathématique forte utilisant le formalisme mathématique de
-  l'algorithmique algébrique est en général enseignée en France uniquement aux cours
-  des grandes écoles.
-
-- L'algorithmique présentée ici est donc délibérément pseudo-scientifique mais en revanche
-  ouverte au multi-paradigme. En général l'évocation d'un algorithme en pseudo code est toujours
-  réducteur car limité au style de programmation le plus à la mode actuellement, c'est-à-dire le
-  style impératif. Nous présenterons un éventail des plus grands paradigmes de programmation
-  existants. Nous nous limiterons à la programmation impérative, fonctionnelle, modulaire,
-  générique et objet. Nous envisagerons les structures de données et les structures de contrôle
-  spécifiques à chacun des styles évoqués.
-
-- Et parce qu'un honnête programmeur doit avoir une vue d'ensemble de l'état de son art,
-  nous évoquerons un panorama des différents langages existants -- historiques et contemporains --
-  en les comparants les uns aux autres.
-
-- Durant tout le cours, nous souhaitons proposer une pédagogie par l'exemple, et nous nous
-  limiterons l'exposé à deux langages : principalement le Python3 pour la programmation
-  impérative, modulaire et objet, mais nous évoquerons aussi certains exemples en langage OCaml
-  à propos de la programmation fonctionnelle et générique.
-
-
-- Introduire certains domaines et résultats importants de
-  l’informatique théorique
diff --git a/algorithmique/cours/algo.txt b/algorithmique/cours/algo.txt
index 2b0e255..f561d77 100644
--- a/algorithmique/cours/algo.txt
+++ b/algorithmique/cours/algo.txt
@@ -59,60 +59,6 @@ mathématiques dans certains rôles immuables et ignorerait le fait que les
 existants abstraits qui naissent de la structure d'un domaine plus concret
 peuvent à leur tour servir de domaine de base pour la genèse d'autres existants.
 
-
-Types d'algorithmes
--------------------
-
-La boucle
-~~~~~~~~~~
-
-Différents types de boucles (suites récurrentes, goto, boucle for...)
-
-
-.. 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}
-
 L'algorithme comme généralisation de la calculabilité
 ------------------------------------------------------
 
@@ -121,6 +67,93 @@ impose d'élaborer un nouveau mode de description des méthodes de calcul (appel
 susceptible de satisfaire à la fois le critère de sécurité (maîtrise du résultat) et la possibilité
 d'implémenter les calculs sur un ordinateur.
 
+Exemple d'algorithme
+---------------------
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{L'alorithme de Bellman-Kalaba}
+    \begin{algorithmic}[1]
+    \Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
+    \ForAll {$v \in V(G)$}
+    \State $l(v) \leftarrow \infty$
+    \EndFor
+    \State $l(u) \leftarrow 0$
+    \Repeat
+    \For {$i \leftarrow 1, n$}
+    \State $min \leftarrow l(v_i)$
+    \For {$j \leftarrow 1, n$}
+    \If {$min > e(v_i, v_j) + l(v_j)$}
+    \State $min \leftarrow e(v_i, v_j) + l(v_j)$
+    \State $p(i) \leftarrow v_j$
+    \EndIf
+    \EndFor
+    \State $l(i) \leftarrow min$
+    \EndFor
+    \State $changed \leftarrow l \not= l’$
+    \State $l \leftarrow l$
+    \Until{$\neg changed$}
+    \EndProcedure
+    \Statex
+    \Procedure {FindPathBK}{$v$, $u$, $p$}
+    \If {$v = u$}
+    \State \textbf{Write} $v$
+    \Else
+    \State $w \leftarrow v$
+    \While {$w \not= u$}
+    \State \textbf{Write} $w$
+    \State $w \leftarrow p(w)$
+    \EndWhile
+    \EndIf
+    \EndProcedure
+    \end{algorithmic}
+    \end{algorithm}
+
+Exemple d'algorithme avec son implémentation
+---------------------------------------------
+
+Soit l'algorithme de factorielle suivant,
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Algorithme de la factorielle d'un nombre}\label{factorielle}
+    \begin{algorithmic}[1]
+    \Function{factorielle}{$n$}\Comment{La fonction récursive factorielle}
+    \BState \emph{parametre} : $n$ entier
+    \If{$n = 1$}
+    \BState \emph{Sortie} : 1
+    \Else
+    \BState \emph{Sortie} : $n * \Call{factorielle}{n-1}$ \Comment{On appelle la fonction dans l'algorithme lui-même}
+    \EndIf
+    \EndFunction
+    \end{algorithmic}
+    \end{algorithm}
+
+et son implémentation en python :
+
+.. literalinclude:: code/factorielle.py
+    :language: python
+
+En voici une autre implémentation (en OCaml) :
+
+.. literalinclude:: code/factorielle.ml
+    :language: ocaml
+
+On remarque que le **pseudocode** (l'algorithme vague) est très proche de
+la syntaxe du python :
+
+.. function:: factorielle(n:int)
+
+::
+
+       if n=1
+          return 1
+       else
+          return n * factorielle(n-1)
+       end if
+
 Qualité d'un algorithme
 -----------------------
 
@@ -245,7 +278,5 @@ C'est utile pour pouvoir comparer des algorithmes.
 
 complexité
 
-	estimer la complexité d'unalgorithme,
-    c'est-à-dire estimer le nombre de calculs qu'il utilise.
-
-analyse de complexité
+	estimer la complexité d'un algorithme,
+  c'est-à-dire estimer le nombre de calculs qu'il utilise.
diff --git a/algorithmique/cours/annexes/agile.txt b/algorithmique/cours/annexes/agile.txt
index 43dd756..5884c11 100644
--- a/algorithmique/cours/annexes/agile.txt
+++ b/algorithmique/cours/annexes/agile.txt
@@ -1,5 +1,5 @@
-Les méthodes  agile
-===================
+La planification  agile
+========================
 
 Le mode itératif
 -----------------
diff --git a/algorithmique/cours/annexes/exercices.txt b/algorithmique/cours/annexes/exercices.txt
new file mode 100644
index 0000000..af41f52
--- /dev/null
+++ b/algorithmique/cours/annexes/exercices.txt
@@ -0,0 +1,122 @@
+Première journée : Le langage Python
+-------------------------------------
+
++------------------------------------------------------+------------------------------------------------------------------------+
+| Contenus                                             | Précisions et commentaires                                             |
++======================================================+========================================================================+
+| Recherche dans une liste, recherche du maximum dans  |                                                                        |
+| une liste de nombres, calcul de la moyenne et de la  |                                                                        |
+| variance.                                            |                                                                        |
++------------------------------------------------------+------------------------------------------------------------------------+
+| Recherche d’un mot dans une chaîne de caractères.    | On se limite ici à l’algorithme "naïf", en estimant sa complexité.     |
++------------------------------------------------------+------------------------------------------------------------------------+
+
+
+Séance 1 : Un apercu des possibles utilisations de Python
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
++ Objectif de la formation
+
++ les outils de travail avec Python
+    + éditeur de texte + IPython (commandes intéractives + `%run`)
+    + environnement de développement intégré (ex. Spyder)
+    + Notebook IPython (proche de Maple/Mathematica)
+
+
+Séance 2 : Éléments de base du langage
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- structures de données
+    + (),[],{}
+    + listes en compréhension
+
+- éléments du langage
+        boucles, conditions, fonctions, itérateur, map , enumerate
+
+- Exemple en algorithmique de base
+
+::
+
+    In [1]: def tri1():
+
+    %timeit l1.sort()
+
+Séance 3 : Chaînes et fichiers
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    + traitement des chaines de caractères
+        + s.replace()
+        + s1 + s2
+    + un exemple de regexp simple
+    + type de fichiers
+        + mode d'accès
+    + glob.glob
+    + Sans doute ces points peuvent être intégrés dans la séance 2.
+
+Séance 8 : Cas pratique de mise en oeuvre
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
++ écrire des instructions conditionnelles avec alternatives,
++ démontrer qu’une boucle se termine effectivement.
++ organisation modulaire des programmes
++ programmation structurée.
+
+    1. Récupérer des données physiques ouvertes sur le réseau (T°, ...)
+
+
++ **Variables** : notion de type et de valeur d’une  variable, types simples.
+    Les types simples présentés sont les  entiers, flottants, booléens et chaînes de caractères.
+
++ **Expressions et instructions simples** :
+    affectation, opérateurs usuels, distinction entre expression et instruction
+     Les expressions considérées sont à valeurs numériques, booléennes ou de type chaîne de caractères.
+
++ **Instructions conditionnelles**:
+    expressions booléennes et opérateurs logiques simples, structurer et comprendre plusieurs
+    instruction if. Variantes avec alternative (else).
+
+Les étudiants devront être capables de niveaux d’alternatives implantées par des instructions conditionnelles imbriquées.
+
++ **Instructions itératives** :
+    boucles for, boucles conditionnelles while.
+    Les sorties de boucle (instruction break) peuvent être présentées et se
+    justifient uniquement lorsqu’elles contribuent à simplifier notablement la
+    programmation sans réelle perte de lisibilité des conditions d’arrêt.
+
++ **Fonctions** :
+  notion de fonction (au sens informatique), définition dans le langage utilisé, paramètres (ou arguments) et résultats, portée des variables.
+  On distingue les variables locales des variables globales et on décourage l’utilisation des variables globales autant que possible.
+
+  La récursivité sera présentée plus tard.
+
++ **Manipulation de quelques structures de données**:
+    chaînes de caractères (création, accès à un caractère, concaténation), listes (création, ajout
+    d’un élément, suppression d’un élément, accès à un élément, extraction d’une partie de liste), tableaux à une ou plusieurs dimensions.
+
+    On met en évidence le fait que certaines opérations d’apparence simple cachent
+    un important travail pour le processeur.  On met à profit la structure de
+    tableau d’entiers à deux dimensions pour introduire la notion d’image
+    ponctuelle (« bitmap »). Les algorithmes de traitement d’image seront abordés
+    plus tard.
+
++ **Fichiers** :
+    notion de chemin d’accès, lecture et écriture de données numériques ou de type chaîne de caractères depuis ou vers un fichier.
+
+    On encourage l’utilisation de fichiers en tant que supports de données ou de résultats avant divers traitements, par exemple graphiques.
+
+
++ **Piles**
+    Algorithmes de manipulation : fonctions 'push' et 'pop'. On utilise des listes
+    (ou tableaux à 1 dimension) pour leur implantation.
+
++ **Récursivité**
+
+    On en présente les avantages et les inconvénients.
+
++ **Tris** d’un tableau à une dimension de valeurs
+    numériques : tri par insertion, tri rapide (ou 'quicksort'),
+    tri par fusion. Application à la
+    recherche de la médiane d’une liste de nombres.
+
+    On étudie et on compare ces algorithmes de tri du point de vue des complexités temporelles dans le meilleur et dans le
+    pire cas.
diff --git a/algorithmique/cours/annexes/index.txt b/algorithmique/cours/annexes/index.txt
index 5101b23..566502a 100644
--- a/algorithmique/cours/annexes/index.txt
+++ b/algorithmique/cours/annexes/index.txt
@@ -4,6 +4,6 @@ Annexes
 .. toctree::
     :maxdepth: 2
 
+    exercices
     agile
     scrum
-
diff --git a/algorithmique/cours/code/factorielle.ml b/algorithmique/cours/code/factorielle.ml
new file mode 100644
index 0000000..5065a2c
--- /dev/null
+++ b/algorithmique/cours/code/factorielle.ml
@@ -0,0 +1,17 @@
+let rec fact = function
+    |1 -> 1
+    | n -> n * fact (n-1) ;;
+
+let print_fact n =
+  Printf.printf "factorielle %i = %i\n" n (fact n)
+
+let main () = 
+  begin 
+    print_fact 5 ;
+    print_newline () ;
+    exit 0 ;
+  end
+
+let _ = main ()
+
+
diff --git a/algorithmique/cours/code/factorielle.py b/algorithmique/cours/code/factorielle.py
new file mode 100644
index 0000000..734719f
--- /dev/null
+++ b/algorithmique/cours/code/factorielle.py
@@ -0,0 +1,12 @@
+def factorielle(n):
+    if (n > 1):
+       r  = n*factorielle(n-1)
+    else:
+        r = 1
+    return r
+
+def print_fact(n):
+    print "factorielle {} = {}\n".format(5, factorielle(5))
+
+if __name__ == '__main__':
+    print_fact(5)
diff --git a/algorithmique/cours/control.txt b/algorithmique/cours/control.txt
index 53a02ca..0208fc3 100644
--- a/algorithmique/cours/control.txt
+++ b/algorithmique/cours/control.txt
@@ -1,5 +1,5 @@
-Structures de contrôle
-======================
+Les tructures de contrôle
+==========================
 
 L'instruction de saut conditionnel
 ----------------------------------
@@ -16,11 +16,11 @@ L'instruction de saut conditionnel
    \If {$i > \textit{stringlen}$} \Return false
    \EndIf
    \State $j \gets \textit{patlen}$
-   \BState \emph{loop}: \Comment{C'est le label (l'étiquette)}
+   \BState \emph{loop}: \Comment{C'est le label (l'étiquette)} \label{etiquette}
    \If {$\textit{string}(i) = \textit{path}(j)$}
    \State $j \gets j-1$.
    \State $i \gets i-1$.
-   \State \textbf{goto} \emph{loop}.
+   \State \textbf{goto} \emph{loop}. \label{goto}
    \State \textbf{close};
    \EndIf
    \State $i \gets
@@ -31,11 +31,16 @@ L'instruction de saut conditionnel
    \end{algorithm}
 
 
-- **Ligne 7**, le bloc `loop` est aussi un **label** (une étiquette), c'est-à-dire
-  une marque posée qu'il est possible de retrouver dans le programme.
-- **Ligne 11**, l'instruction `goto` (aller à ) est un saut.
+.. raw:: latex
 
-D'une manière générale::
+    Ligne \ref{etiquette}, le bloc `loop` est aussi un label (une étiquette),
+    c'est-à-dire une marque posée qu'il est possible de retrouver dans le programme. \\
+
+.. raw:: latex
+
+    Ligne \ref{goto}, l'instruction \texttt{goto} (aller à ) est le saut vers le label. \\
+
+Description générique d'une instruction de saut::
 
   Instruction 1
   Saut Label1
@@ -47,3 +52,88 @@ D'une manière générale::
 .. important:: les sauts conditionnels sont à éviter, même s'ils sont implémentés
                dans le langage cible, car c'est le meilleur moyen d'aboutir à
                du **code spaghetti**.
+
+L'instruction de test
+~~~~~~~~~~~~~~~~~~~~~~
+
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple d'instruction de test}
+    \begin{algorithmic}[1]
+    \BState \emph{entrée}: $quality\gets 0$ \Comment{C'est cette valeur qui sera testée}
+    \BState \emph{locale}: $a\gets ""$
+    \BState \emph{sortie}: $a$ \Comment{La sortie est la valeur de $a$}
+    \BState \emph{corps}:
+    \If{$quality\ge 9$}
+    \State $a\gets perfect$
+    \ElsIf{$quality\ge 7$}
+    \State $a\gets good$
+    \ElsIf{$quality\ge 5$}
+    \State $a\gets medium$
+    \ElsIf{$quality\ge 3$}
+    \State $a\gets bad$
+    \Else
+    \State $a\gets unusable$
+    \EndIf
+    \end{algorithmic}
+    \end{algorithm}
+
+
+Les boucles
+-----------
+
+.. important:: Toutes les boucles concernent le paradigme de programmation impératif
+               et ne sont pas valides dans le paradigme de programmation fonctionnel
+               (puisque l'ordre d'évaluation importe)
+
+Répéter ... jusqu'à
+~~~~~~~~~~~~~~~~~~~
+
+.. raw:: latex
+
+   \begin{algorithm}
+    \caption{Exemple de répéter ... jusqu'à}
+   \begin{algorithmic}[1]
+   \Require $i \gets 1$ \Comment{déclaration et initialisation de i}
+   \Statex
+   \Repeat \Comment{c'est le label de début du répéter}
+   \State $i \gets \textit{i+1}$
+   \Until{i == 100} \Comment{condition de fin de la boucle}
+   \end{algorithmic}
+   \end{algorithm}
+
+La boucle **pour** (for)
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple de boucle for}
+    \begin{algorithmic}[1]
+    \Require  $sum\gets 0$
+    \Statex
+    \For{$i\gets 1, n$}
+    \State $sum\gets sum+i$
+    \EndFor
+    \end{algorithmic}
+    \end{algorithm}
+
+La boucle tant que (while)
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple de boucle while}
+    \begin{algorithmic}[1]
+    \Require $sum\gets 0$
+    \Statex
+    \State $i\gets 1$
+    \While{$i\le n$}
+    \State $sum\gets sum+i$
+    \State $i\gets i+1$
+    \EndWhile
+    \end{algorithmic}
+    \end{algorithm}
diff --git a/algorithmique/cours/fondement.txt b/algorithmique/cours/fondement.txt
index af45b06..15e6ce4 100644
--- a/algorithmique/cours/fondement.txt
+++ b/algorithmique/cours/fondement.txt
@@ -1,6 +1,15 @@
 Présentation de l'art de programmer
 ====================================
 
+Qu'est-ce que la programmation ?
+--------------------------------
+
+programmation
+
+    Description d’un calcul (traitement) dans
+    un langage compréhensible par la machine
+    (langage de programmation)
+
 Le processus d'abstraction
 --------------------------
 
@@ -18,18 +27,18 @@ explication du fonctionnement d'une machine abstraite de bas niveau, puis en
 allant de plus en plus haut, mais étant sous-entendu qu'il faut rester connecté au
 bas niveau (comprendre comment ça se passe derrière la scène).
 
-Dans ces deux cas, il est sous-entendu qu'on apprend plus de choses et plus rapidement en mettant 
-les mains dans le cambouis, ce qui vrai bien sûr. Mais cela sous-entend qu'un développeur doit 
-rester le nez dans le guidon. Qu'il doit être un expert de son domaine en accumulant des technos 
-sans aucun recul. Bie sûr il se doit d'être un expert du système dans lequel il évolue 
-(connaissance du système d'exploitation, binding avec le C, du ramasse miette (garbage 
-collector), interaction avec les différentes librairies, gestion et optimisation de la mémoire, 
+Dans ces deux cas, il est sous-entendu qu'on apprend plus de choses et plus rapidement en mettant
+les mains dans le cambouis, ce qui vrai bien sûr. Mais cela sous-entend qu'un développeur doit
+rester le nez dans le guidon. Qu'il doit être un expert de son domaine en accumulant des technos
+sans aucun recul. Bie sûr il se doit d'être un expert du système dans lequel il évolue
+(connaissance du système d'exploitation, binding avec le C, du ramasse miette (garbage
+collector), interaction avec les différentes librairies, gestion et optimisation de la mémoire,
 architecture par microservices, threads...) mais il doit aussi être capable de prendre du recul.
 
-L'approche algorithmique (algorithmique de pseudo code, algorithmique algébrique et modulaire) 
-est un véritable moyen pour le programmeur de prendre du recul : elle commence par se placer du 
-côté de l'esprit humain et de ses capacités de compréhension et d'abstraction, elle autorise une 
-pensée rationnelle sur l'art de programmer et permet au programmeur d'effectuer les bons choix, 
+L'approche algorithmique (algorithmique de pseudo code, algorithmique algébrique et modulaire)
+est un véritable moyen pour le programmeur de prendre du recul : elle commence par se placer du
+côté de l'esprit humain et de ses capacités de compréhension et d'abstraction, elle autorise une
+pensée rationnelle sur l'art de programmer et permet au programmeur d'effectuer les bons choix,
 en connaissance de sa discipline.
 
 Le lien est fait ensuite avec le plus bas niveau grâce une implémentation effective
@@ -99,4 +108,41 @@ plus efficace.
   programmation indépendant de l'état de la mémoire de l'ordinateur,
   ils sont indépendant même du système d'exploitation.
 
+Qu'est-ce qu'une machine ?
+---------------------------
 
+Une machine, ce truc apparemment si complexe, est en fait
+un assemblage de bric et de brac.
+
+L'assemblage des connecteurs permet de simuler un additionneur,
+en prenant en compte les propriétés de **reste euclidien**
+de l'addition.
+
+La structure électronique est composée de :
+
+- un ordonnanceur.
+- le stockage d'un **état**.
+- une pile d'instruction
+
+.. glossary::
+
+    adressage
+
+        Dès lors qu'on dispose de ces bases électronique au dessus du processeur,
+        un langage d'assemblage est possible, c'est le langage de calcul sur les registres.
+
+    registre
+
+        machines ont un espace mémoire et un espace de calcul (registres)
+
+Un ordinateur, c'est très très stupide, mais ça permet de disposer de :
+
+- une mémoire très grande et ordonnée,
+- une capacité à effectuer inlassablement des tâches répétitives
+- une grande rapidité de calcul
+
+Apprendre à programmer, c'est-à-dire être capable de
+contrôler la machine.
+
+.. important:: Apprendre à programmer, c'est-à-dire apprendre à penser de manière structurée,
+               pour pouvoir accessoirement ensuite communiquer avec une machine.
diff --git a/algorithmique/cours/index.txt b/algorithmique/cours/index.txt
index 51d3dc5..a4cdce6 100644
--- a/algorithmique/cours/index.txt
+++ b/algorithmique/cours/index.txt
@@ -4,12 +4,12 @@ Introduction à l'algorithmique
 .. toctree::
     :maxdepth: 2
 
+    presentation
     fondement
     langage
-    modularite
     algo
     programme
+    fonctions
     control
-    machine
+    modularite
     annexes/index
-
diff --git a/algorithmique/cours/langage.txt b/algorithmique/cours/langage.txt
index ae4b948..0302694 100644
--- a/algorithmique/cours/langage.txt
+++ b/algorithmique/cours/langage.txt
@@ -1,6 +1,30 @@
 Les langages de programmation
 =============================
 
+langage
+
+    Un langage de
+    programmation
+    doit permettre d'écrire des
+    programmes de bonne qualité
+
+Un programme doit être :
+
+- correct
+- robuste
+- lisible, bien documenté
+- facile à modifier, extensible
+
+Un langage de programmation doit permettre :
+
+- la programmation structurée
+- la structuration avec les types
+- proposer un mécanisme d’exceptions
+- présenter des caractères de généricité, de polymorphisme et de surcharge
+
+.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
+               Elles sont une nécessité
+
 Approche historique et chronologique
 -------------------------------------
 
@@ -287,3 +311,24 @@ en retour les langages. On reconnaît aujourd'hui :
 - Le modèle de programmation système et réseau
 - le modèle **Dev Ops** et les méthodes de développement virtualisés
 - les langages présentant des **fonctionnalités agiles**
+
+Conclusion
+-----------
+
+Les langages de haut niveau sont caractérisés par
+des concepts tels que :
+
+- déclaration de valeurs, types, expressions, portée
+- expressions, variables, instructions, structures de contrôle
+- fonctions, procédures, fermetures
+- encapsulation, modules, objets
+
+===========  ============
+Paradigmes   Concepts
+===========  ============
+impératif    variables, procédures, modules
+objets       classes, méthodes, héritage, surcharge
+fonctionnel  fonctions, fermetures, modules
+logique      prédicats, modules
+concurrent   tâche/processus, communication
+===========  ============
diff --git a/algorithmique/cours/machine.txt b/algorithmique/cours/machine.txt
deleted file mode 100644
index b0e9c77..0000000
--- a/algorithmique/cours/machine.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-Machine abstraite
------------------
-
-une machine, ce truc apparemment si complexe, est en fait 
-un assemblage de bric et de brac. 
-
-l'assemblage des connecteurs permet de simuler un additionneur, 
-en prenant en compte les propriétés de **reste euclidien**
-de l'addition. 
-
-la structure électronique est composée de :
-
-- un ordonnanceur. 
-- le stockage d'un **état**.
-- une pile d'instruction
-
-dès lors qu'on dispose de ces bases électronique au dessus du processeur,
-un langage d'assemblage est possible, c'est le langage de calcul sur les registres. 
-
-l'adressage mémoire
-
-
-registre
-
-    machines ont un espace mémoire et un espace de calcul (registres)
-     
-      
diff --git a/algorithmique/cours/modularite.txt b/algorithmique/cours/modularite.txt
index d102a7f..13920c0 100644
--- a/algorithmique/cours/modularite.txt
+++ b/algorithmique/cours/modularite.txt
@@ -1,6 +1,12 @@
-L'organisation d'un programme
+Introduction à la modularité
 =============================
 
+
+Un langage de programmation doit permettre la programmation structurée.
+
+.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
+               Elles sont une nécessité
+
 Structuration d'un programme
 -----------------------------
 
@@ -33,6 +39,9 @@ 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
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -55,31 +64,31 @@ Structuration et sûreté d'exécution
 La preuve de programme
 ~~~~~~~~~~~~~~~~~~~~~~
 
-Le niveau maximum de sûreté d'exécution d'un programme est la preuve. Qu'est-ce que la preuve 
-formelle d'un programme ? Selon la définition de Wikipédia, ce sont "des techniques permettant de 
-raisonner rigoureusement, à l'aide de logique mathématique, sur des programmes informatiques ou 
-du matériel électroniques, afin de démontrer leur validité par rapport à une certaine 
-spécification." Bref c'est un raisonnement logique sur un programmme qui permet d'être sûr que le 
+Le niveau maximum de sûreté d'exécution d'un programme est la preuve. Qu'est-ce que la preuve
+formelle d'un programme ? Selon la définition de Wikipédia, ce sont "des techniques permettant de
+raisonner rigoureusement, à l'aide de logique mathématique, sur des programmes informatiques ou
+du matériel électroniques, afin de démontrer leur validité par rapport à une certaine
+spécification." Bref c'est un raisonnement logique sur un programmme qui permet d'être sûr que le
 programme est valide et ne va pas planter.
 
-La preuve de programme est très peu utilisée dans l'industrie, car très coûteuse et très 
-difficile à mettre en place. Elle quand même utilisée, mais dans des secteurs où le risque doit 
-absolument être évacué et où il n'y a aucun droit à l'erreur. Par exemple, le secteur médical 
-(informatique en bloc opératoire), militaire (peu d'informations nous parviennent dans ce 
-domaine), l'aviation civile (le logiciel Astrée pour Airbus), la fusée Ariane (depuis le bug qui 
-avait fait crasher Ariane 5 ces questions sont prises très au sérieux), et le milieu bancaire 
-(surtout le domaine des décisions boursières : un programme chargé de lancer des décisions 
-d'achat ou de vente à la bourse qui comporte un bug peut en quelque centièmes de secondes faire 
-perdre des millions, voire des milliards d'euros à une banque. Le programme ne doit tout simplement pas 
+La preuve de programme est très peu utilisée dans l'industrie, car très coûteuse et très
+difficile à mettre en place. Elle quand même utilisée, mais dans des secteurs où le risque doit
+absolument être évacué et où il n'y a aucun droit à l'erreur. Par exemple, le secteur médical
+(informatique en bloc opératoire), militaire (peu d'informations nous parviennent dans ce
+domaine), l'aviation civile (le logiciel Astrée pour Airbus), la fusée Ariane (depuis le bug qui
+avait fait crasher Ariane 5 ces questions sont prises très au sérieux), et le milieu bancaire
+(surtout le domaine des décisions boursières : un programme chargé de lancer des décisions
+d'achat ou de vente à la bourse qui comporte un bug peut en quelque centièmes de secondes faire
+perdre des millions, voire des milliards d'euros à une banque. Le programme ne doit tout simplement pas
 bugger).
 
 Le model checking
 ~~~~~~~~~~~~~~~~~~
 
-Le model checking, l'analyse statique et l'interprétation abstraite procèdent d'une méthodologie 
-moins lourde de validation des programmes. Ces méthodes analysent exhaustivement l'évolution du 
-système lors de ses exécutions possibles et permetent de dire si globalement, dans un contexte 
-donné, le programme va fonctionner correctement. Encore très lourdes, ces techniques ne sont 
+Le model checking, l'analyse statique et l'interprétation abstraite procèdent d'une méthodologie
+moins lourde de validation des programmes. Ces méthodes analysent exhaustivement l'évolution du
+système lors de ses exécutions possibles et permetent de dire si globalement, dans un contexte
+donné, le programme va fonctionner correctement. Encore très lourdes, ces techniques ne sont
 utilisées que dans un contexte industriel de haute sécurité.
 
 
@@ -89,8 +98,8 @@ Les tests d'acceptation
 C'est sont les tests unitaires et fonctionnels
 
 
-Très utilisés dans l'industrie, les tests unitaires et fonctionnels ne testent que certaines 
-parties du programme et permettent de dire que le programme va marcher grosso-modo à peu près. 
+Très utilisés dans l'industrie, les tests unitaires et fonctionnels ne testent que certaines
+parties du programme et permettent de dire que le programme va marcher grosso-modo à peu près.
 Beaucoup moins coûteux à installer, ce sont des éléments cléfs des méthodes agiles.
 
 
@@ -110,27 +119,27 @@ cher à payer.
 Les méthodologies agiles
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-La manière dont le code est produit importe énormément. Par exemple, une 
-méthodologie ou le **refactoring** (réécriture de code) est permis et même conseillé 
+La manière dont le code est produit importe énormément. Par exemple, une
+méthodologie ou le **refactoring** (réécriture de code) est permis et même conseillé
 a plus de chance de produire du code organisé.
 
-Les méthodologies agiles produisent en général du code mieux organisé. Ce sont les 
+Les méthodologies agiles produisent en général du code mieux organisé. Ce sont les
 méthodes de travail les plus en vogue aujourd'hui, elles mettent l'accent sur :
 
 - Du logiciel fonctionnel plutôt que de la documentation exhaustive
 - La réponse au changement plutôt que le suivi d'un plan
 - Le logiciel fonctionnel est la principale mesure d'avancement
-- Une attention continue à l'excellence technique et à une bonne 
+- Une attention continue à l'excellence technique et à une bonne
   conception améliore l'agilité
 - La simplicité est essentielle (il est facile de faire, il est
   difficile de faire simple)
 
-Le principe de base de la méthodologie Scrum par exemple est de focaliser l'équipe de façon 
-itérative sur un ensemble de fonctionnalités à réaliser, dans des itérations de durée fixe de une 
-à quatre semaines, appelées **sprints**. Chaque sprint possède un but à atteindre, défini par le 
-responsable de produit, à partir duquel sont choisies les fonctionnalités à implémenter dans ce 
-sprint. Un sprint aboutit toujours sur la livraison d'un produit partiel fonctionnel. Pendant ce 
-temps, le facilitateur a la charge de réduire au maximum les perturbations extérieures et de 
+Le principe de base de la méthodologie Scrum par exemple est de focaliser l'équipe de façon
+itérative sur un ensemble de fonctionnalités à réaliser, dans des itérations de durée fixe de une
+à quatre semaines, appelées **sprints**. Chaque sprint possède un but à atteindre, défini par le
+responsable de produit, à partir duquel sont choisies les fonctionnalités à implémenter dans ce
+sprint. Un sprint aboutit toujours sur la livraison d'un produit partiel fonctionnel. Pendant ce
+temps, le facilitateur a la charge de réduire au maximum les perturbations extérieures et de
 résoudre les problèmes non techniques de l'équipe.
 
 
@@ -143,3 +152,20 @@ Les Outils de linting (validation)
 
 Exemple en python : pylint
 
+Les modules
+-----------
+
+Il s'agit de décomposer un grand programme en
+morceaux (**modules**) connectés entre eux par des **interfaces** bien
+définies.
+
+Ces modules doivent être aussi indépendants que possible.
+
+module
+
+    ensemble de ressources  liées sémantiquement
+
+interface
+
+    mode d’emploi du module, avec en plus un principe de masquage
+    des informations (partie publique, partie secrète)
diff --git a/algorithmique/cours/presentation.txt b/algorithmique/cours/presentation.txt
new file mode 100644
index 0000000..ab7873b
--- /dev/null
+++ b/algorithmique/cours/presentation.txt
@@ -0,0 +1,52 @@
+Avant propos
+============
+
+Introduction
+~~~~~~~~~~~~
+
+- L'accent est mis sur l'approche **algorithmique scientifique**, dite algorithmique
+  algébrique. L'algorithmique est un sous-domaine de l'algèbre et des
+  approches modulaires (arithmétique modulaire...)
+
+- Le point de vue mathématique étant assez exigeant, **aucun formalisme fort** de
+  l'algorithmique mathématique ne sera présenté. Aucun symbole mathématique donc, et
+  seulement du pseudo-code.
+  L'approche mathématique forte utilisant le formalisme mathématique de
+  l'algorithmique algébrique est en général enseignée en France uniquement aux cours
+  des grandes écoles.
+
+- L'algorithmique présentée ici est donc délibérément pseudo-scientifique mais en revanche
+  ouverte au **multi-paradigme**. En général l'évocation d'un algorithme en pseudo code est toujours
+  réducteur car limité au style de programmation le plus à la mode actuellement, c'est-à-dire le
+  **style impératif**. Nous présenterons un éventail des plus grands paradigmes de programmation
+  existants. Nous nous limiterons à la **programmation impérative, fonctionnelle, modulaire,
+  générique et objet**. Nous envisagerons les structures de données et les structures de contrôle
+  spécifiques à chacun des styles évoqués.
+
+- Et parce qu'un honnête programmeur doit avoir une vue d'ensemble de **l'état de son art**,
+  nous évoquerons un panorama des différents langages existants -- historiques et contemporains --
+  en les comparants les uns aux autres.
+
+- Durant tout le cours, nous souhaitons proposer une pédagogie par l'exemple, et nous nous
+  limiterons l'exposé à deux langages d'implémentation des algorithmes : le **Python** pour la programmation
+  impérative, modulaire et objet, et nous évoquerons aussi certains exemples en langage **OCaml**
+  à propos de la programmation fonctionnelle, modulaire et générique.
+
+Objectifs de ce cours
+~~~~~~~~~~~~~~~~~~~~~
+
+Il s'agit de :
+
+- maîtriser  et concevoir un algorithmes de base,
+- choisir une représentations appropriée des données,
+- décomposer en sous-problèmes et affinements successifs,
+- organiser les modules ou fonctions.
+
+Le développement raisonné d’algorithmes et leur implantation
+permet d'acquérir les qualités suivantes :
+
++   Analyser et modéliser un problème,
++   Spécifier,
++   Exprimer, une problématique, une solution ou un algorithme,
++   Traduire un algorithme dans un langage de programmation,
++   Concevoir un algorithme répondant à un problème précisément posé.
diff --git a/algorithmique/cours/programme.txt b/algorithmique/cours/programme.txt
index 6dec7ad..2fad8ef 100644
--- a/algorithmique/cours/programme.txt
+++ b/algorithmique/cours/programme.txt
@@ -2,17 +2,107 @@ Définition d'un programme
 ==========================
 
 Qu'est-ce qu'un programme ?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+----------------------------
 
-- Un programme est une suite de phrases
-- Une phrase est une **déclaration** ou une **expression**.
-- Le signe "égal" est utilisé lorsqu'une une déclaration ou une expression sont équivalentes
+- Un **programme** est une suite de **phrases** ;
+- Une **phrase** est une **déclaration** ou une **expression** (*statement* en anglais) ;
 
-Les déclarations
+Production d'un programme :
+
+1. on écrit le code source du programme ;
+2. on demande au compilateur de le traduire en code machine : c'est la compilation du programme ;
+3. on demande à la machine d'effectuer le code machine : c'est l'exécution du programme.
+
+.. important::
+
+    L'introduction à la compilation et les différentes phases de la compilation
+    d'un programme sont des sujets qui ne seront pas traités dans ce cours.
+
+Dans un programme de base, il y a deux fichiers :
+
+1. un fichier contenant le code : c'est le source du programme.
+2. un fichier contenant le code machine : c'est l'exécutable.
+
+Que peut faire un programme lorsqu'il est exécuté ?
+Le programme doit communiquer. S'il reste isolé, il ne pourra pas
+produire quoi que ce soit. Voici les trois moyens de communication qu'a un
+programme :
+
+1. communiquer avec l'utilisateur,
+2. communiquer avec des fichiers,
+3. communiquer avec d'autres programmes.
+
+Les expressions
 ----------------
 
-Renseigner une variable
+expression
 
+    Une expression est une valeur caculée du langage, une opération arithmétique
+    qui retourne une valeur (entier, texte, valeur logique...).
+    C'est donc une suite sémantiquement correcte de **valeurs de base** et **d'opérateurs**
+
+Par exemple, la ligne suivante est une expression effectuant une addition::
+
+    5 + 6
+
+Autres exemples d'expressions :
+
+- 5 est une expression de type int
+- 4.5 est une expression de type float
+- 'c' est une expression de type char
+- true est une expression de type bool
+- print ('c') est une expression de type None
+- raw_input est une expression de type string
+
+Un autre exemple d'expression :
+
+.. raw:: latex
+
+    \begin{algorithm}
+    \caption{Exemple d'expression}
+    \begin{algorithmic}[1]
+    \BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée}
+    \ForAll {$v \in V(G)$}
+    \State $l(v) \leftarrow \infty$
+    \EndFor
+    \State $l(u) \leftarrow 0$
+    \Repeat
+    \For {$i \leftarrow 1, n$}
+    \State $min \leftarrow l(v_i)$
+    \For {$j \leftarrow 1, n$}
+    \If {$min > e(v_i, v_j) + l(v_j)$}
+    \State $min \leftarrow e(v_i, v_j) + l(v_j)$
+    \State $p(i) \leftarrow v_j$
+    \EndIf
+    \EndFor
+    \State $l(i) \leftarrow min$
+    \EndFor
+    \State $changed \leftarrow l \not= l’$
+    \State $l \leftarrow l$
+    \Until{$\neg changed$}
+    \end{algorithmic}
+    \end{algorithm}
+
+On voit qu'une expression peut-être complexe, dans tous les cas une valeur
+est renvoyée.
+
+Les déclarations
+-----------------
+
+Exemple de déclarations :
+
+- `a = 1`
+- `b = 'c'`
+
+.. important:: Le signe égal est utilisé de deux manières
+
+               - lors d'une déclaration d'une expression
+               - lorsque deux expressions sont équivalentes
+
+               Suivant les langages, il y a deux symboles différents, ou alors
+               ils sont identiques.
+
+Il s'agit de **renseigner** une valeur dans une expression nommée
 
 - en javascript :
 
@@ -38,10 +128,13 @@ Renseigner une variable
 
     let a = 1
 
-(**let** : soit `a` la variable... )
+Grâce au mécanisme d'inférence de type dans OCaml, le mot-clef **let**
+signifie ici véritablement l'instanciation d'une valeur au sens
+mathématique du terme : soit `a` l'entier tel que a soit égal à 1...
 
-En OCaml comme dans tous les langages fonctionnels, toutes les "variables"
-(les affectations) sont en fait des **constantes**.
+En OCaml comme dans tous les langages fonctionnels, tout ce que nous avons l'habitude
+d'appeler des "variables" à propos des affectations, sont en fait des **constantes**
+au sens du paradigme impératif de la programmation.
 
 .. important::
 
@@ -68,10 +161,9 @@ Exemples dans la langue française :
 
 .. glossary::
 
-
     affectation
 
-        une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.
+        Une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.
 
         Il s'agit d'une structure particulièrement courante en programmation impérative, et dispose souvent pour cette raison d'une notation courte et infixée,
         comme ``x = expr`` ou ``x := expr`` ou encore `x <- expr`.
@@ -97,97 +189,61 @@ Voir aussi :
 
     x1 = e1, x2 = e2, ... xn = en;
 
-Les fonctions
--------------
+Interaction avec l'utilisateur
+------------------------------
 
-Préliminaire : rappel de théorie de l'information
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Il est possible de communiquer de la manière suivante avec un programme :
 
-Théorie de l'information (Claude Shannon, 1949), théorie de la
-communication
+- lire et écrire sur l'entrée/sortie standard
+- lire et écrire dans un fichier
+- afficher du texte ou un nombre
+- lire du texte ou un nombre
+- manipuler les prompts
 
-canal de transmission::
+La REPL
+--------
 
-    entrée -> récepteur -> émetteur -> sortie
+.. glossary::
 
-Description d'une procédure
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    REPL
 
-- une procédure peut prendre des paramètres
-- elle modifie l'état courant du système
+      Read Eval Print Loop : outil principal de communication avec un programme
+      ou avec un système. Exemples : la console python, le prompt OCaml.
 
-- Déclaration des paramètes
-- Déclaration du corps
-- Appel de la procédure
+    interface
 
-.. raw:: latex
+      outil de communication avec un programme.
 
-   \begin{algorithm}
-   \caption{Procédure de permutation de deux entiers}\label{permutation}
-   \begin{algorithmic}[1]
-   \Procedure{permuter}{$a,b$}{}
-   \BState \emph{parametres}:
-   \State $a: \textit{int}$
-   \State $b: \textit{int}$
-   \BState \emph{locales}:
-   \State $z: \textit{int}$ \Comment{Une variable intermédiaire est nécessaire}
-   \BState \emph{corps}:
-   \State $z \gets a$
-   \State $a \gets b$
-   \State $b \gets z$
-   \EndProcedure
-   \end{algorithmic}
-   \end{algorithm}
+      - interface texte
+      - interface graphique
 
+**Exemples de REPL**
 
-effet de bord
+Le prompt python::
 
-    toute modification de la mémoire ou modification d'un support externe
+      Python 2.7.12 (default, Nov 19 2016, 06:48:10)
+      [GCC 5.4.0 20160609] on linux2
+      Type "help", "copyright", "credits" or "license" for more information.
+      >>>
+      >>> dir()
+      ['__builtins__', '__doc__', '__name__', readline', 'rlcompleter']
+      >>>
+Le prompt ipython::
 
-instruction
+    Python 2.7.12 (default, Nov 19 2016, 06:48:10)
+    Type "copyright", "credits" or "license" for more information.
 
-  commande ou phrase en mesure de modifier l'état du programme ou de la machine hôte
-	(allocation mémoire, support externe, disque, écran...)
+    IPython 2.4.1 -- An enhanced Interactive Python.
+    ?         -> Introduction and overview of IPython's features.
+    %quickref -> Quick reference.
+    help      -> Python's own help system.
+    object?   -> Details about 'object', use 'object??' for extra details.
 
-Une procédure ne renvoie pas de valeur, mais provoque un 'effet de bord' (écriture dans une globale, dans un flux sortant etc.).
+    In [1]:
 
-Une procédure permet de créer une instruction nouvelle qui deviendra une primitive pour le programmeur
-Cela permet de structurer le texte source du programme et améliorer sa
-lisibilité. Cela permet aussi d'appeler plusieurs fois, et à plusieurs endroit
-dans le code, cette primitive.
+Le prompt OCaml (utop)::
 
-Appel d'une procédure
-~~~~~~~~~~~~~~~~~~~~~
+        Type #utop_help for help about using utop.
 
-(ex: pseudo-pascal)
-
-**déclaration de procédure**
-
-::
-
-    procedure p(x1, ..., xn);
-        var v1,...,vm;
-
-- les variables x1,...,xn sont appelées *paramètres formels* de p
-- les variables v1,...,vm sont appelées *les variables locales* de p
-
-**appel de procédure**
-
-::
-
-    p(e1, ..., en)
-
-les expressions e1,...,en sont appelées paramètres effectifs de p
-
-SYRACUSE
-
-Le niveau d’une déclaration (de variable ou de procédure) est le nombre
-de procédures sous lesquelles elle est déclarée. Le programme principal
-a le niveau 0.
-
-Description d'une fonction
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Une fonction renvoie une valeur et ne modifie pas l'état courant du programme
-en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie
-**toujours** quelque chose (même la valeur ``None`` qui n'est pas rien)
+        ─( 09:21:24 )─< command 0 >──
+        utop #
diff --git a/algorithmique/index.txt b/algorithmique/index.txt
deleted file mode 100644
index d22df1d..0000000
--- a/algorithmique/index.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-Introduction à l'algorithmique
-================================
-
-.. index pour générer de l'HTML
-
-
-Contents:
-
-.. toctree::
-    :maxdepth: 2
-
-    fondement
-    langage
-    modularite
-    machine
-
-
-
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`
-