diff --git a/README.md b/README.md
index 8cd38e4304ca98d3c7c4af3423e07d045b9bdcb4..882b8a942af7e3ed0e30aa2edcb5e863180b3d16 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,14 @@
 # Numeric
 
+## Changelog
+
+- 16.10.2019: Tas binaire à réaliser
+- 5.11.2019: 
+  - Abandon de l'implémentation à l'aide d'un sous-arbre gauche et droite
+  - Uniquement une abstraction + une implémentation avec liste ou tableau
+  - L'abstraction doit avoir au moins deux méthodes par défaut
+  - Corrigez le nom de la méthode `exist` en `exists`
+
 
 Ce repository contient l'énoncé du TP "numeric" et un squelette maven.
 Nous vous conseillons de vous abonner aux notifications (watch) pour ne pas manquer des annonces ou des changements.
@@ -103,57 +112,72 @@ Les constructeurs doivent être non publiques. Pour créer un élément, vous de
 
 TBD
 
+
+
 ## Fonctionnalités à réaliser sur les tas binaires (*binary heap*)
 
-Nous vous demandons d'implémenter un tas d'entiers binaire de priorité maximale. Un tas binaire est une structure de données pouvant être représentée comme un arbre binaire. Chaque noeud a au maximum deux noeuds enfants (gauche et droit). La valeur de la donnée contenue dans un noeud (dans notre cas un nombre entier) doit être supérieure ou égale à celles contenues dans ses éventuels enfants. La racine de cet arbre contient ainsi la valeur la plus grande du tas (et ceci en permanence). Tous les niveaux de cet arbre doivent être pleins, à l'exception du dernier. Si ce dernier niveau n'est pas entièrement rempli, il doit l'être de gauche à droite, comme sur la figure ci-dessous.
+Nous vous demandons d'implémenter un tas d'entiers binaire de priorité maximale. Un tas binaire est une structure 
+de données pouvant être représentée comme un arbre binaire. Chaque noeud a au maximum deux noeuds 
+enfants (gauche et droit). La valeur de la donnée contenue dans un noeud (dans notre cas un nombre entier) doit 
+être supérieure ou égale à celles contenues dans ses éventuels enfants. La racine de cet arbre contient ainsi la valeur 
+la plus grande du tas (et ceci en permanence). Tous les niveaux de cet arbre doivent être pleins, à l'exception du 
+dernier. Si ce dernier niveau n'est pas entièrement rempli, il doit l'être de gauche à droite, comme sur la figure ci-dessous.
 
 <p><a href="https://commons.wikimedia.org/wiki/File:Max-Heap.svg#/media/Fichier:Max-Heap.svg"><img src="https://upload.wikimedia.org/wikipedia/commons/thumb/3/38/Max-Heap.svg/1200px-Max-Heap.svg.png" alt="Max-Heap.svg" width="500"><br></a>Un tas-max. Par <a href="//commons.wikimedia.org/w/index.php?title=User:Ermishin&amp;action=edit&amp;redlink=1" class="new" title="User:Ermishin (page does not exist)">Ermishin</a> — <span class="int-own-work" lang="fr">Travail personnel</span>, <a href="https://creativecommons.org/licenses/by-sa/3.0" title="Creative Commons Attribution-Share Alike 3.0">CC BY-SA 3.0</a>, <a href="https://commons.wikimedia.org/w/index.php?curid=12251273">Lien</a></p>
 
-Vous devrez fournir deux implémentations, la première à l'aide d'une liste (tableau) et la deuxième à l'aide d'un arbre proprement dit (sans réutiliser de structure d'arbre existante dans la librairie standard Java). Utilisez une bonne abstraction permettant de comparer les deux implémentations. Votre code devra être placé dans le package `ch.hepia.structure`.
+Nous souhaitons une abstraction d'un tas binaire ainsi qu'une implémentation à l'aide d'un tableau statique ou d'une liste.
 
-### Implémentation avec une liste
-- La racine se situe à l'index 0.
+Vous devrez également implémenter une méthode `populate()`, prenant en arguments une impémentation d'un tas binaire et
+qui la peuple en fonction d'un nombre de valeurs aléatoire donné en argument. Cette méthode dépend évidemment d'une
+abstraction.
 
-- Étant donné un noeud à l'index `i`, son enfant gauche est à l'index `2i+1` et son enfant droit à `2i+2`.
+Votre code devra être placé dans le package `ch.hepia.structure`.
+
+### Implémentation avec une liste ou un tableau
 
+- La racine se situe à l'index 0.
+- Étant donné un noeud à l'index `i`, son enfant gauche est à l'index `2i+1` et son enfant droit à `2i+2`.
 - Étant donné un noeud à l'index i > 0, son parent est à l'index `(i-1) / 2` (arrondi à l'entier inférieur).
 
 <p><a href="https://commons.wikimedia.org/wiki/File:Binary_tree_in_array.svg#/media/Fichier:Binary_tree_in_array.svg"><img src="https://upload.wikimedia.org/wikipedia/commons/thumb/8/86/Binary_tree_in_array.svg/1200px-Binary_tree_in_array.svg.png" alt="Binary tree in array.svg" width="500"><br></a>Un tas binaire implémenté avec un tableau, domaine public, <a href="https://commons.wikimedia.org/w/index.php?curid=488485">Lien</a></p>
 
 ### Méthodes à implémenter
-Chaque implémentation devra fournir ces méthodes :
+
+Un tas binaire doit fournir ces méthodes :
+
 - `push()` : ajoute un entier au tas et rétablit l'ordre du tas si nécessaire
 - `pop()` : retourne et retire la racine du tas et rétablit l'ordre du tas
 - `peek()` : retourne (sans retirer) la racine du tas
 - `addAll(list)` : ajoute tous les éléments de la liste `list` au tas
 - `isEmpty()` : indique si le tas est vide ou non
-- `exist(k)` : indique si l'entier `k` est présent dans le tas
+- `exists(k)` : indique si l'entier `k` est présent dans le tas
 - `size()` : retourne le nombre d'éléments contenus dans le tas
 - `depth()` : retourne la profondeur (*id est* le nombre de niveaux) du tas
 
-Vous devrez également implémenter une méthode `populate()`, prenant en arguments une de vos implémentations et la peuplant d'un nombre de valeurs aléatoires donné en argument également.
+Réalisez au moins deux méthodes dans l'abstraction d'un tas binaire.
 
 ### Exemple d'utilisation
 
 Voici un exemple d'utilisation en pseudo-code Java :
 
 ```java
-IntBinaryHeap listBinaryHeap = ...
-IntBinaryHeap treeBinaryHeap = ...
-
-populate(listBinaryHeap, 17);
-populate(treeBinaryHeap, 23);
-
-assertEquals(listBinaryHeap.size(), 17);
-assertEquals(treeBinaryHeap.size(), 23);
-System.out.println(treeBinaryHeap.peek());
-listBinaryHeap.push(42);
-...
+public class App {
+    public static void populate(???) {
+        ...
+    }
+    public static void main(String[] args) {
+        IntBinaryHeap heap = new ArrayIntBinaryHeap();
+        populate( heap );
+        while( !heap.isEmpty() ) {
+            System.out.println( heap.pop() );
+        }
+    }
+}
 ```
 
 ### Tests unitaires
 
-Vous devrez fournir également des tests unitaires, à mettre dans le package `ch.hepia.structure` du répertoire `test`, qui valident vos deux implémentations.
+Vous devrez fournir également des tests unitaires, à mettre dans le package `ch.hepia.structure` du répertoire `test`, qui valident votre implémentation.
 
 ## Maven