Merge remote-tracking branch 'adambard/master'

22 files changed, 4376 insertions, 59 deletions

diff --git a/fr-fr/HTML-fr.html.markdown b/fr-fr/HTML-fr.html.markdown
index fdde9107..b52fd34a 100644
--- a/fr-fr/HTML-fr.html.markdown
+++ b/fr-fr/HTML-fr.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Christophe THOMAS", "https://github.com/WinChris"]
 lang: fr-fr
 ---
+
 HTML signifie HyperText Markup Language. 
 C'est un langage (format de fichiers) qui permet d'écrire des pages internet.
 C’est un langage de balisage, il nous permet d'écrire des pages HTML au moyen de balises (Markup, en anglais).
@@ -17,7 +18,7 @@ Comme tous les autres langages, HTML a plusieurs versions. Ici, nous allons parl
 Cet article porte principalement sur la syntaxe et quelques astuces.
 
 
-```HTML
+```html
 <!-- Les commentaires sont entouré comme cette ligne! -->
 
 <!-- #################### Les balises #################### -->
@@ -105,6 +106,8 @@ Cet article porte principalement sur la syntaxe et quelques astuces.
 	</tr>
 </table>
 
+```
+
 ## Utilisation
 
 Le HTML s'écrit dans des fichiers `.html`.
diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/bf-fr.html.markdown
index 545e407e..0fae6032 100644
--- a/fr-fr/brainfuck-fr.html.markdown
+++ b/fr-fr/bf-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 filename: learnbrainfuck-fr.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
diff --git a/fr-fr/binary-search-fr.html.markdown b/fr-fr/binary-search-fr.html.markdown
new file mode 100644
index 00000000..4c34da0f
--- /dev/null
+++ b/fr-fr/binary-search-fr.html.markdown
@@ -0,0 +1,67 @@
+---
+category: Algorithms & Data Structures
+name: Binary Search
+contributors:
+    - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"]
+translators:
+    - ["Hughes Perreault", "https://github.com/hperreault"]
+lang: fr-fr
+---
+
+# Recherche Binaire
+
+## Pourquoi la Recherche Binaire ?
+
+La recherche est un des principaux problèmes dans le domaine de l'informatique. De nos jours, il y a plus de 1 milliard de recherches par année, et nous avons besoin d'algorithmes pour faire cela rapidement. La recherche binaire est un des algorithmes les plus fondamentaux en informatique. Pour pouvoir l'explorer en détail, nous allons d'abord établir une base théorique, puis nous allons utiliser cette base pour implémenter l'algorithme en soi.
+
+## Introduction
+
+Une façon simple d'implémenter la recherche est de faire une recherche linéaire. Cependant, cette approche prend beaucoup de temps, et ce temps augmente linéairement avec la quantité de données. Par exemple, partons du premier élément d'un tableau t[], et un par un, comparons x avec chaque élément de t[]. Si x est égal à un élément, nous retournons l'index, si x n'égale aucun élément, nous retournons -1.
+
+```
+Recherche Linéaire: O (n)               Temps Linéaire
+
+Recherche Binaire:  O ( log(n) )        Temps Logarithmique
+
+```
+```
+def search(arr, x):
+
+    for i in range(len(arr)):
+
+        if arr[i] == x:
+            return i
+
+    return -1
+
+```
+## L'Algorithme de Recherche Binaire
+
+Le prérequis fondamental de la recherche binaire est que les éléments soient triés.
+
+### Algo
+
+```
+L'idée derrière la recherche binaire est d'utiliser le fait que le tableau est trié afin de réduire la complexité à O(Log(n)). Nous pouvons ignorer la moitié des éléments après la première comparaison.
+1) Comparons x avec l'élément du milieu.
+2) Si x est égal à cet élément, nous retournons l'index du milieu.
+3) Sinon, si x est plus grand que l'élément du milieu, alors x peut seulement être dans la dernière moitié du tableau. Donc, nous recommençons la procédure avec cette dernière moitié.
+4) Sinon (x est plus petit), nous recommençons la procédure avec la première moitié du tableau.
+Ensuite nous avons une implémentation récursive de la recherche binaire.
+
+```
+
+### Note de la fin
+
+Partie en construction.
+
+## Livre
+
+* [CLRS EN](https://mitpress.mit.edu/books/introduction-algorithms)
+* [Algorithmes EN](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Design d'Algorithmes EN](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Ressources en ligne
+
+* [GeeksforGeeks EN](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)
+* [Topcoder Tutorial EN](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/)
diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown
new file mode 100644
index 00000000..acbaed58
--- /dev/null
+++ b/fr-fr/c++-fr.html.markdown
@@ -0,0 +1,916 @@
+---
+language: c++
+filename: learncpp-fr.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+translators:
+    - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"]
+lang: fr-fr
+---
+
+C++ est un langage de programmation système qui,
+[selon son créateur Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+fut créé pour
+
+- être un "C amélioré"
+- gérer l'abstraction des données
+- gérer la programmation orienté objet
+- gérer la programmation générique
+
+Bien que sa syntaxe puisse être plus difficile ou complexe que des langages
+récents, il est largement utilisé car il compile en instructions natives qui
+peuvent être directement exécutées par le processeur et offre un contrôle
+rigoureux du matériel (comme le C) tout en fournissant des caractéristiques de
+haut niveau telles que la généricité, les exceptions et les classes.
+Cette combinaison de vitesse et de fonctionnalités rend le C++ un des langages
+de programmation les plus utilisés au monde.
+
+```c++
+/////////////////////////////////
+// Comparaison avec le C
+/////////////////////////////////
+
+// C++ est _presque_ un sur-ensemble du C et partage sa syntaxe basique pour les
+// déclarations de variables, les types primitifs et les fonctions.
+
+// Tout comme en C, le point d'entrée de votre programme est une fonction
+// appelée main, avec un integer comme type de retour.
+// Cette valeur constitue l'état de fin d'exécution du programme.
+// Voir http://en.wikipedia.org/wiki/Exit_status pour plus d'informations.
+int main(int argc, char** argv)
+{
+    // Les arguments de ligne de commande sont passés avec argc et argv de la
+    // même manière qu'en C.
+    // argc indique le nombre d'arguments,
+    // et argv est un tableau de chaînes façon C (char*)
+    // représentant les arguments.
+    // Le premier argument est le nom par lequel le programme est appelé.
+    // argc et argv peuvent être omis si vous ne vous souciez pas des
+    // arguments, nous donnant comme signature de fonction int main()
+
+    // Un état de fin d'exécution 0 indique le succès.
+    return 0;
+}
+
+// Cependant, C++ varie du C selon certains éléments:
+
+// En C++, les caractères littéraux sont des chars
+sizeof('c') == sizeof(char) == 1
+
+// En C, les caractères littéraux sont des ints
+sizeof('c') == sizeof(int)
+
+// C++ a un prototypage strict
+void func(); // fonction qui ne prend aucun argument
+
+// En C
+void func(); // fonction qui peut prendre n'importe quel nombre d'arguments
+
+// Utilise nullptr au lieu de NULL in C++
+int* ip = nullptr;
+
+// Les en-têtes standards du C sont disponibles en C++,
+// mais son préfixés avec "c" et n'ont pas de suffixe .h
+#include <cstdio>
+
+int main()
+{
+    printf("Bonjour tout le monde!\n");
+    return 0;
+}
+
+/////////////////////////////////
+// Surchage de fonctions
+/////////////////////////////////
+
+// C++ gère la surchage de fonctions
+// Chaque fonction fournie prend différents paramètres.
+
+void print(char const* maChaine)
+{
+    printf("Chaîne %s\n", maChaine);
+}
+
+void print(int monEntier)
+{
+    printf("Mon entier est %d", monEntier);
+}
+
+int main()
+{
+    print("Bonjour"); // Utilise void print(const char*)
+    print(15); // Utilise void print(int)
+}
+
+/////////////////////////////////////////////
+// Arguments par défaut de fonctions
+/////////////////////////////////////////////
+
+// Vous pouvez fournir des arguments par défaut pour une fonction s'ils ne sont
+// pas fournis par l'appelant.
+
+void faitDesChosesAvecDesEntiers(int a = 1, int b = 4)
+{
+    // Do something with the ints here
+}
+
+int main()
+{
+    faitDesChosesAvecDesEntiers();      // a = 1,  b = 4
+    faitDesChosesAvecDesEntiers(20);    // a = 20, b = 4
+    faitDesChosesAvecDesEntiers(20, 5); // a = 20, b = 5
+}
+
+// Les arguments par défaut doivent être à la fin de la liste des arguments.
+
+void invalidDeclaration(int a = 1, int b) // Erreur !
+{
+}
+
+
+//////////////////////////
+// Espaces de nom
+//////////////////////////
+
+// Les espaces de nom fournissent une séparation des portées pour les
+// variables, fonctions, et autres déclarations.
+// Les espaces de nom peuvent être imbriqués.
+
+namespace Premier {
+    namespace Imbrique {
+        void foo()
+        {
+            printf("Ceci est le Premier::Imbrique::foo\n");
+        }
+    } // fin de l'espace de nom Imbrique
+} // fin de l'espace de nom Premier
+
+namespace Second {
+    void foo()
+    {
+        printf("Ceci est le Second::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("Ceci est un foo global\n");
+}
+
+int main()
+{
+    // Inclut tous les symboles de l'espace de nom Second dans la portée
+    // actuelle. Notez que le foo() simple ne marche plus, car l'appel est
+    // ambigu entre le foo de l'espace de nom Second et celui de premier
+    // niveau.
+    using namespace Second;
+
+    Second::foo(); // imprime "Ceci est le Second::foo"
+    Premier::Imbrique::foo(); // imprime "Ceci est le Premier::Imbrique::foo"
+    ::foo(); // imprime "Ceci est un foo global"
+}
+
+/////////////////////////
+// Entrée/Sortie
+/////////////////////////
+
+// Les entrées et sorties en C++ utilisent des flux (streams)
+// cin, cout et cerr représentent stdin, stdout et stderr.
+// << est l'opérateur d'insertion et >> est l'opérateur d'extraction.
+
+#include <iostream> // Inclusion pour les flux d'entrée/sortie
+
+// Les flux sont dans l'espace de nom std (librairie standard)
+using namespace std;
+
+int main()
+{
+   int monEntier;
+
+   // Affiche sur stdout (ou le terminal/l'écran)
+   cout << "Entrez votre chiffre favori:\n";
+   // Prend l'entrée clavier
+   cin >> monEntier;
+
+   // cout peut également être formaté
+   cout << "Votre chiffre favori est " << monEntier << "\n";
+   // imprime "Votre chiffre favori est <monEntier>"
+
+    cerr << "Utilisé pour les messages d'erreurs";
+}
+
+/////////////////////////////////
+// Chaînes de caractères
+/////////////////////////////////
+
+// Les chaînes de caractères en C++ sont des objets et ont plusieurs fonctions
+// membres
+#include <string>
+
+// Les chaînes de caractères sont aussi dans l'espace de
+// nom std (librairie standard)
+using namespace std;
+
+string maChaine = "Bonjour";
+string monAutreChaine = " tout le monde !";
+
+// + est utilisé pour la concaténation.
+cout << maChaine + monAutreChaine; // Bonjour tout le monde !"
+
+cout << maChaine + " toi !"; // "Bonjour toi !"
+
+// Les chaînes de caractères C++ sont mutables.
+maChaine.append(" le chien !");
+cout << maChaine; // "Bonjour le chien !"
+
+
+//////////////////////
+// Références
+//////////////////////
+
+// En plus des pointeurs comme ceux en C,
+// C++ possède des _références_.
+// Ce sont des types de pointeurs qui ne peuvent pas être réassignés
+// une fois initialisés, et ne peuvent pas être nulles.
+// Ils partagent la même syntaxe que les variables elles-mêmes:
+// les * ne sont pas nécessaires pour les déréférencer et
+// & (addresse de) n'est pas utilisé pour l'assignement.
+
+using namespace std;
+
+string foo = "Je suis foo";
+string bar = "Je suis bar";
+
+
+string& fooRef = foo; // Ceci créé une référence à foo
+fooRef += ". Salut!"; // Modifie foo à travers la référence
+cout << fooRef; // Affiche "Je suis foo. Salut!"
+
+// Ne réassigne pas "fooRef". Ceci revient à faire "foo = bar", et
+// foo == "I am bar"
+// après cette ligne.
+cout << &fooRef << endl; // Affiche l'adresse de foo
+fooRef = bar;
+cout << &fooRef << endl; // Affiche toujours l'adresse de foo
+cout << fooRef;  // Affiche "Je suis bar"
+
+// L'adresse de fooRef reste la même, c.-à-d. référence toujours foo.
+
+
+const string& barRef = bar; // Créé une référence constante de bar.
+// Comme en C, les valeurs constantes (et pointeurs et références) ne peuvent
+// être modifiées.
+
+// Erreur, les valeurs constantes ne peuvent être modifiées.
+barRef += ". Salut!";
+
+// Parenthèse: avant de développer le sujet des références, nous devons
+// introduire un concept appelé un objet temporaire. Supposons que nous ayons
+// le code suivant :
+string objetTemporaireFun() { ... }
+string valeurRetenu = objetTemporaireFun();
+
+// Les différents événements se déroulant à la seconde ligne sont :
+//   - un objet chaîne de caractères est retourné de objetTemporaireFun
+//   - une nouvelle chaîne de caractères est construite avec la valeur
+//     retournée comme argument du constructeur
+//   - l'objet retourné est détruit.
+// L'objet retourné est appelé un objet temporaire. Les objets temporaires sont
+// créés chaque fois qu'une fonction retourne un objet, et sont détruits à la
+// fin de l'évaluation de l'expression fermante (c'est ce que le standard
+// énonce, mais les compilateurs sont autorisés à changer ce comportement.
+// Cherchez "optimisation valeur de retour" si vous êtes intéressé par ce genre
+// de détails).
+// Dans cette ligne de code :
+foo(bar(objetTemporaireFun()))
+
+// en supposant que foo et bar existent, l'objet retourné de objetTemporaireFun
+// est passé à bar, et est détruit avant que foo soit appelé.
+
+// Revenons maintenant aux références. L'exception à la règle "objet détruit à
+// la fin de l'expression fermante" s'applique dans le cas d'un objet
+// temporaire lié à une référence constante, où sa durée de vie se voit
+// prolongée à la portée courante :
+
+void referenceConstanteObjetTemporaireFun() {
+  // referenceConst prend l'objet temporaire, et est valide jusqu'à la fin de
+  // la fonction.
+  const string& referenceConst = objetTemporaireFun();
+  ...
+}
+
+// Un autre type de référence introduit en C++11 est spécifiquement pour les
+// objets temporaires. Vous ne pouvez pas avoir de variable de ce type, mais
+// il prime dans la résolution de surcharge :
+
+void fonctionFun(string& s) { ... }  // Référence régulière
+void fonctionFun(string&& s) { ... }  // Référence un objet temporaire
+
+string foo;
+// Appelle la version avec référence régulière
+fonctionFun(foo);
+
+// Appelle la version avec référence temporaire
+fonctionFun(objetTemporaireFun());
+
+// Par exemple, vous aurez ces deux versions de constructeurs pour
+// std::basic_string :
+basic_string(const basic_string& other);
+basic_string(basic_string&& other);
+
+// L'idéal étant de construire une nouvelle chaîne de caractères avec un objet
+// temporaire (qui sera détruit de toute façon), nous pouvons ainsi avoir un
+// constructeur qui "sauve" des parties de cette chaîne de caractères
+// temporaire. Vous verrez ce concept sous le nom de "sémantique de mouvement".
+
+////////////////////////
+// Enumérations
+////////////////////////
+
+// Les énumérations sont un moyen d'assigner une valeur à une constante
+// fréquemment utilisée pour une meilleure visualisation et lecture du code.
+enum ETypesDeVoitures
+{
+  Berline,
+  Hayon,
+  4x4,
+  Break
+};
+
+ETypesDeVoitures ObtenirVoiturePreferee()
+{
+	return ETypesDeVoitures::Hayon;
+}
+
+// En C++11, il existe une manière simple d'assigner un type à une énumération,
+// ce qui peut-être utile en sérialisation de données et conversion
+// d'énumérations entre le type voulu et ses constantes respectives.
+enum ETypesDeVoitures : uint8_t
+{
+  Berline, // 0
+  Hayon, // 1
+  4x4 = 254, // 254
+  Hybride // 255
+};
+
+void EcrireOctetDansLeFichier(uint8_t ValeurEntree)
+{
+	// Sérialise la valeur d'entrée dans un fichier
+}
+
+void EcrireTypeVoiturePrefereDansLeFichier(ETypesDeVoitures TypeVoitureEntree)
+{
+	// L'énumération est implicitement convertie en uint8_t du à la déclaration
+    // de son type d'énumération
+	EcrireOctetDansLeFichier(TypeVoitureEntree);
+}
+
+// D'autre part, vous pourriez ne pas vouloir que des énumérations soient
+// accidentellement converties en entiers ou en d'autres énumérations. Il est
+// donc possible de créer une classe d'énumération qui ne sera pas
+// implicitement convertie.
+enum class ETypesDeVoitures : uint8_t
+{
+  Berline, // 0
+  Hayon, // 1
+  4x4 = 254, // 254
+  Hybride // 255
+};
+
+void EcrireOctetDansLeFichier(uint8_t ValeurEntree)
+{
+	// Sérialise la valeur d'entrée dans un fichier
+}
+
+void EcrireTypeVoiturePrefereDansLeFichier(ETypesDeVoitures TypeVoitureEntree)
+{
+	// Ne compilera pas même si ETypesDeVoitures est un uint8_t car
+	// l'énumération est déclarée en tant que "classe d'énumération" !
+	EcrireOctetDansLeFichier(TypeVoitureEntree);
+}
+
+///////////////////////////////////////////////////
+// Classes et programmation orientée objet
+///////////////////////////////////////////////////
+
+#include <iostream>
+
+// Déclare une classe.
+// Les classes sont habituellement déclarées dans les fichiers d'en-tête (.h ou .hpp).
+class Chien {
+    // Les variables et fonctions membres sont privées par défaut.
+    std::string nom;
+    int poids;
+
+// Tous les membres suivants sont publiques jusqu'à ce que "private:" ou
+// "protected:" soit trouvé
+public:
+
+    // Constructeur par défaut
+    Chien();
+
+    // Déclaractions de fonctions membres (implémentations à suivre)
+    // Notez que nous utilisons std::string ici au lieu de placer
+    // using namespace std;
+    // au-dessus.
+    // Ne jamais utiliser une instruction "using namespace" dans l'en-tête.
+    void initialiserNom(const std::string& nomDuChien);
+
+    void initialiserPoids(int poidsDuChien);
+
+    // Les fonctions qui ne modifient pas l'état de l'objet devraient être
+    // marquées en constantes avec const.
+    // Ceci vous permet de les appeler avec une référence constante vers l'objet.
+    // Notez aussi que les fonctions devant être surchargées dans des classes
+    // dérivées doivent être explicitement déclarées avec _virtual_.
+    // Les fonctions ne sont pas virtuelles par défault pour des raisons de
+    // performances.
+    virtual void imprimer() const;
+
+    // Les fonctions peuvent également être définies à l'intérieur du corps de
+    // la classe. Ces fonctions sont automatiquement "inline".
+    void aboyer() const { std::cout << nom << " fait ouaf !\n"; }
+
+    // En plus des constructeurs, C++ fournit des destructeurs.
+    // Ils sont appelés quand l'objet est supprimé ou dépasse le cadre de sa
+    // portée. Ceci permet de puissants paradigmes tels que RAII
+    // (voir plus loin)
+    // Le destructeur devrait être virtuel si la classe est abstraite;
+    // s'il n'est pas virtuel, alors le destructeur de la classe dérivée ne
+    // sera pas appelé si l'objet est détruit par le biais d'une référence à la
+    // classe de base ou d'un pointeur.
+    virtual ~Chien();
+
+}; // Un point virgule doit clôre la définition de la classe.
+
+// Les fonctions membres de la classe sont habituellement implémentées dans des
+// fichiers .cpp.
+Chien::Chien()
+{
+    std::cout << "Un chien a été construit\n";
+}
+
+// Les objets (comme les chaînes de caractères) devraient être passés par
+// référence si vous les modifiez ou par référence constante si vous ne les
+// modifiez pas.
+void Chien::initialiserNom(const std::string& nomDuChien)
+{
+    nom = nomDuChien;
+}
+
+void Chien::initialiserPoids(int poidsDuChien)
+{
+    poids = poidsDuChien;
+}
+
+// Notez que le mot-clé "virtual" est nécessaire uniquement à la déclaration,
+// et non à la définition.
+void Chien::imprimer() const
+{
+    std::cout << "Le chien s'appelle " << nom << " et pèse " << poids << "kg\n";
+}
+
+Chien::~Chien()
+{
+    cout << "Au revoir " << nom << " !\n";
+}
+
+int main() {
+    Chien monChien; // imprime "Un chien a été construit"
+    monChien.initialiserNom("Barkley");
+    monChien.initialiserPoids(10);
+    monChien.imprime(); // imprime "Le chien s'appelle Barkley et pèse 10 kg"
+    return 0;
+} // prints "Au revoir Barkley !"
+
+// Héritage :
+
+// Cette classe hérite de toutes les propriétés publiques et protégées de la
+// classe Chien ainsi que celles privées, mais n'ont pas accès direct aux
+// membres et méthodes privés sans l'aide d'une méthode publique ou protégée
+class ChienDomestique : public ChienDomestique {
+
+    void definirProprietaire(const std::string& proprietaireDuChien);
+
+    // Surcharge le comportement de la fonction d'impression pour tous les
+    // ChienDomestiques.
+    // Voir https://fr.wikipedia.org/wiki/Polymorphisme_(informatique)#Polymorphisme_par_sous-typage
+    // pour une introduction plus générale si vous n'êtes pas familier avec le
+    // concept de polymorphisme par sous-typage (appelé aussi polymorphisme
+    // d'inclusion).
+    // Le mot-clé "override" est optionnel mais assure que vous surchargez bien
+    // la méthode de la classe de base.
+    void imprimer() const override;
+
+private:
+    std::string proprietaire;
+};
+
+// Pendant ce temps, dans le fichier .cpp correspondant :
+
+void ChienDomestique::definirProprietaire(const std::string& proprietaireDuChien)
+{
+    proprietaire = proprietaireDuChien;
+}
+
+void ChienDomestique::imprimer() const
+{
+    // Appelle la fonction "imprimer" dans la classe de base Chien
+    Chien::imprimer();
+    std::cout << "Le chien appartient à " << proprietaire << "\n";
+    // Affiche "Le chien est <nom> et pèse <poids>"
+    //         "Le chien appartient à <proprietaire>"
+}
+
+////////////////////////////////////////////////////
+// Initialisation et opérateur de surcharge
+////////////////////////////////////////////////////
+
+// En C++, vous pouvez surcharger le comportement d'opérateurs tels
+// que +, -, *, /, etc.
+// La surcharge se fait en définissant une fonction qui sera appelée à chaque
+// fois que l'opérateur sera utilisé.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Les variables membres peuvent avoir des valeurs par défaut
+    double x = 0;
+    double y = 0;
+
+    // Définit un constructeur par défaut qui ne fait rien
+    // mais initialise le Point à la valeur par défaut (0, 0)
+    Point() { };
+
+    // La syntaxe suivante s'appelle une liste d'initialisation et est
+    // la façon correcte d'initialiser les valeurs des membres d'une classe.
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* Ne fait rien à part initialiser les valeurs */ }
+
+    // Surcharge l'opérateur +
+    Point operator+(const Point& rhs) const;
+
+    // Surcharge l'opérateur +=
+    Point& operator+=(const Point& rhs);
+
+    // Il serait également logique d'ajouter les opérateurs - et -=,
+    // mais nous les éclipsons par soucis de concision.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // Créé un nouveau point qui est la somme de celui-ci de rhs.
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point haut (0,1);
+    Point droite (1,0);
+    // Appelle l'opérateur + du Point
+    // Le point "haut" appelle la fonction + avec "droite" comme paramètre
+    Point resultat = haut + droite;
+    // Affiche "Le résultat est haut-droite (1,1)"
+    cout << "Le résultat est haut-droite (" << resultat.x << ','
+         << resultat.y << ")\n";
+    return 0;
+}
+
+////////////////////////////////
+// Patrons (templates)
+////////////////////////////////
+
+// Les templates (patrons) en C++ sont majoritairement
+// utilisés pour la programmation générique, bien qu'ils soient bien plus
+// puissants que les constructeurs génériques dans d'autres langages.
+// Ils gèrent également la spécialisation explicite et partielle ainsi que
+// les classes fonctionnelles; en fait, ils sont un langage fonctionnelles
+// Turing-complete embedded in C++ !
+
+// Nous commencons avec le genre de programmation générique auquel vous êtes
+// peut-être familier. Pour définir une classe ou fonction qui prend un type de
+// paramètre particulier :
+template<class T>
+class Boite {
+public:
+    // Dans cette classe, T représente n'importe quel type possible.
+    void inserer(const T&) { ... }
+};
+
+// Pendant la compilation, le compilateur génère des copies de chaque template
+// avec les paramètres substitués; ainsi, la définition complète de chaque
+// classe doit être présente à chaque appel. C'est pourquoi vous verrez les
+// classes de templates définies entièrement dans les fichiers d'en-tête.
+
+// Pour instancier une classe de template sur la pile ("stack") :
+Boite<int> boiteDEntiers;
+
+// et vous pouvez l'utiliser comme prévu :
+boiteDEntiers.inserer(123);
+
+// Vous pouvez, bien sûr, imbriquer les templates :
+Boite<Boite<int> > boiteDeBoites;
+boiteDeBoites.inserer(boiteDEntiers);
+
+// Jusqu'à C++11, il était nécessaire de placer un espace entre les deux '>'s,
+// sinon '>>' était parsé en tant qu'opérateur de décalage vers la droite.
+
+// Vous croiserez peut-être cette syntaxe
+//   template<typename T>
+// à la place. Les mot-clé 'class' et 'typename' sont _généralement_
+// interchangeables. Pour plus d'explications, allez à
+//   http://en.wikipedia.org/wiki/Typename
+// ou
+// https://fr.wikibooks.org/wiki/Programmation_C-C%2B%2B/Les_templates/Mot-cl%C3%A9_typename
+// (oui, ce mot-clé a sa propre page Wikipedia).
+
+// De manière similaire, un patron de fonction :
+template<class T>
+void aboyerTroisFois(const T& entree)
+{
+    entree.aboyer();
+    entree.aboyer();
+    entree.aboyer();
+}
+
+// Remarquez ici que rien n'est spécifié à propos du type du paramètre. Le
+// compilateur va générer et vérifier le type à chaque appel du patron, c'est
+// pourquoi l'appel de fonction suivant marche pour n'importe quel type 'T' qui
+// a une méthode constante 'aboyer' !
+
+Chien docile;
+docile.initialiserNom("Docile")
+aboyerTroisFois(docile); // Affiche "Docile fait ouaf !" trois fois.
+
+// Les paramètres génériques (ou paramètres template) ne sont pas forcément des
+// classes :
+template<int Y>
+void imprimerMessage() {
+  cout << "Apprenez le C++ en " << Y << " minutes !" << endl;
+}
+
+// Vous pouvez explicitement spécialiser les templates pour un code plus
+// optimisé. Bien sûr, les utilisations effectives de la spécialisation ne sont
+// pas aussi triviales que celle-ci.
+// Notez que vous avez toujours besoin de déclarer la fonction (ou classe)
+// comme template, même si vous spécifiez explicitement tous les paramètres.
+template<>
+void imprimerMessage<10>() {
+  cout << "Apprenez le C++ plus vite en seulement 10 minutes !" << endl;
+}
+
+// Affiche "Apprenez le C++ en 20 minutes !"
+imprimerMessage<20>();
+// Affiche "Apprenez le C++ plus vite en seulement 10 minutes !"
+imprimerMessage<10>();
+
+//////////////////////////////////
+// Gestion des exceptions
+//////////////////////////////////
+
+// La bibliothèque standard fournit quelques types d'exception
+// (voir http://en.cppreference.com/w/cpp/error/exception)
+// mais n'importe quel type peut être lancé en tant qu'exception.
+#include <exception>
+#include <stdexcept>
+
+// Toutes les exceptions lancées à l'intérieur d'un block _try_ peuvent être
+// attrapées par les blocs de traitement d'erreurs (_catch_ handlers).
+try {
+    // N'allouez pas des exceptions sur le tas (heap) en utilisant _new_.
+    throw std::runtime_error("Un problème s'est produit");
+}
+
+// Attrapez les exceptions avec des références constantes si ce sont des objets
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+
+// Attrape n'importe quelle exception non attrapée par les blocs _catch_
+// précédents
+catch (...)
+{
+    std::cout << "Exception inconnue attrapée";
+    throw; // Re-lance l'exception
+}
+
+////////////////
+// RAII
+////////////////
+
+// RAII signifie "Resource Acquisition Is Initialization", soit l'Acquisition
+// d'une Ressource est une Initialisation en français.
+// Il est souvent considéré comme le paradigme le plus puissant en C++ et
+// est le concept simple qu'un constructeur d'un objet acquiert les ressources
+// d'un objet et que le destructeur les libère.
+
+// Afin de comprendre son utilité, considérons une fonction qui utilise la
+// gestion d'un fichier C :
+void faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
+{
+    // Pour commencer, supposns que rien ne peut échouer.
+
+    FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en lecture
+
+    faireQuelqueChoseAvecLeFichier(fh);
+    faireAutreChoseAvec(fh);
+
+    fclose(fh); // Ferme la gestion du fichier.
+}
+
+// Malheureusement, les choses deviennent compliquées avec la gestion
+// d'erreurs. Supposons que fopen échoue, et que faireQuelqueChoseAvecLeFichier
+// et faireAutreChoseAvec retournent des codes d'erreur si elles échouent.
+//  (Les exceptions sont le meilleur moyen de gérer l'échec, mais des
+//   programmeurs, surtout avec un passif en C,
+//   sont en désaccord avec l'utilité des exceptions).
+// Nous devons maintenant vérifier chaque appel en cas d'échec et fermer la
+// gestion du fichier si un problème se produit.
+bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
+{
+    FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en mode lecture.
+    if (fh == nullptr) // Le pointeur retourné est null à un échec.
+        return false; // Signale cet échec à l'appelant.
+
+    // Suppose que chaque fonction retourne faux si elle échoue
+    if (!faireQuelqueChoseAvecLeFichier(fh)) {
+        fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
+        return false; // Propage l'erreur
+    }
+    if (!faireAutreChoseAvec(fh)) {
+        fclose(fh);
+        return false;
+    }
+
+    fclose(fh);
+    return true;
+}
+
+// Les programmeurs en C clarifient souvent tout cela en utilisant goto :
+bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
+{
+    FILE* fh = fopen(nomDuFichier, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!faireQuelqueChoseAvecLeFichier(fh))
+        goto echec;
+
+    if (!faireAutreChoseAvec(fh))
+        goto echec;
+
+    fclose(fh); // Ferme la gestion du fichier
+    return true; // Indique le succès
+
+echec:
+    fclose(fh);
+    return false; // Propage l'erreur
+}
+
+// Si les fonctions indiquent des erreurs en utilisant des exceptions,
+// les choses sont un peu plus claires, mais toujours sous-optimales.
+void faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
+{
+    FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en lecture
+    if (fh == nullptr)
+        throw std::runtime_error("Ouverture du fichier impossible.");
+
+    try {
+        faireQuelqueChoseAvecLeFichier(fh);
+        faireAutreChoseAvec(fh);
+    }
+    catch (...) {
+        // Assurez-vous de bien fermer le fichier si une erreur arrive
+        fclose(fh);
+        throw; // Puis re-lancer l'exception
+    }
+
+    fclose(fh); // Ferme le fichier
+    // Tout s'est déroulé correctement
+}
+
+// Comparez ceci à l'utilisation de la classe de flux de fichier
+// en C++ (fstream).
+// fstream utilise son destructeur pour fermer le fichier.
+// Pour rappel, les destructeurs sont automatiquement appelée dès qu'un objet
+// sort du cadre de sa portée.
+void faireQuelqueChoseAvecUnFichier(const std::string& nomDuFichier)
+{
+    // ifstream is short for input file stream
+    std::ifstream fh(nomDuFichier); // Ouvre le fichier
+
+    // Faire des choses avec le fichier
+    faireQuelqueChoseAvecLeFichier(fh);
+    faireAutreChoseAvec(fh);
+
+} // Le fichier est automatiquement fermé ici par le destructeur
+
+// Ceci a des avantages _énormes_ :
+// 1. Peu importe la situation, la ressource (dans ce cas précis la gestion
+//    de fichier) sera libérée. Si le destructeur est écrit correctement,
+//    il est _impossible_ d'oublier de fermer la gestion et d'entraîner une
+//    une fuite de ressources (si l'objet est sur la pile).
+// 2. Remarquez que le code est beaucoup plus clair.
+//    Le destructeur gère la fermeture du fichier discrètement sans avoir
+//    besoin de s'en préoccuper.
+// 3. Le code est fiable par rapport aux exceptions.
+//    Une exception peut être lancée n'importe où dans la fonction, le
+//    nettoyage se fera toujours.
+
+// Tout code C++ idiomatique utilise considérablement RAII pour toutes les
+// ressources.
+// Des exemples additionnels inclus :
+// - La mémoire utilisant unique_ptr et shared_ptr
+// - Des conteneurs (containers) - la liste chaînée de la librairie standard,
+//   des vecteurs (c.-à-d. tableaux auto-redimensionnés), tables de hachage, et
+//   ainsi de suite. Tous détruisent leur contenu quand ils sortent du cadre
+//   de leur portée.
+// - Les mutex utilisant lock_guard et unique_lock
+
+
+//////////////////
+// Divers
+//////////////////
+
+// Ici sont regroupés des aspects du C++ qui peuvent être surprenants aux
+// novices (et même à quelques habitués).
+// Cette section est, malheureusement, grandement incomplète; C++ est un des
+// langages où il est très facile de se tirer soi-même dans le pied.
+
+// Vous pouvez surcharger des méthodes privées !
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Surcharge Foo::bar!
+};
+
+// 0 == false == NULL (la plupart du temps) !
+bool* pt = new bool;
+*pt = 0; // Affecte false à la valeur de la variable pointée par 'pt'.
+pt = 0;  // Affecte le pointeur null à 'pt'.
+// Les deux lignes compilent sans avertissement.
+
+// nullptr est supposé régler un peu ce problème :
+int* pt2 = new int;
+*pt2 = nullptr; // Ne compile pas
+pt2 = nullptr;  // Affecte null à pt2
+
+// Il y a une exception faite pour les booléens.
+// Ceci vous permet de tester les pointeurs null avec if(!ptr),
+// mais par conséquent, vous pouvez assigner nullptr à un booléen directement !
+*pt = nullptr;  // Ceci compile toujours, même si '*pt' est un booléen !
+
+// '=' != '=' != '='!
+// Appelle Foo::Foo(const Foo&) ou une variante du (voir sémantiques de mouvement)
+// constructeur par copie.
+Foo f2;
+Foo f1 = f2;
+
+// Appelle Foo::Foo(const Foo&) ou une variante, mais copie seulement la partie
+// 'Foo' de 'fooSub'. Tout membre extra de 'fooSub' est ignoré.
+// Ce comportement parfois horrifiant est appelé "object slicing".
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Appelle Foo::operator=(Foo&) ou une variante.
+Foo f1;
+f1 = f2;
+
+// Comment vraiment nettoyer un conteneur :
+class Foo { ... };
+vector<Foo> v;
+for (int i = 0; i < 10; ++i)
+  v.push_back(Foo());
+
+// La ligne suivante affecte la taille de v à 0, mais les destructeurs ne sont
+// appelés et les ressources ne sont pas libérées !
+v.empty();
+// La nouvelle valeur est copiée dans le premier Foo que nous avons inséré
+v.push_back(Foo());
+
+// Ceci nettoie toutes les valeurs de v. Voir la section à propos des objets
+// temporaires pour comprendre pourquoi cela fonctionne.
+v.swap(vector<Foo>());
+
+```
+Lecture complémentaire :
+
+Une référence à jour du langage est disponible à
+<http://cppreference.com/w/cpp>
+
+Des ressources supplémentaires sont disponibles à <http://cplusplus.com>
diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
index 63bc25b5..65747c0d 100644
--- a/fr-fr/clojure-fr.html.markdown
+++ b/fr-fr/clojure-fr.html.markdown
@@ -275,7 +275,7 @@ ressemblent à toutes les autres formes:
 (let [name "Urkel"]
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
-  
+
 ; Utilisez les Threading Macros (-> et ->>) pour exprimer plus
 ; clairement vos transformations, en y pensant de manière multi-niveaux.
 
@@ -284,10 +284,10 @@ ressemblent à toutes les autres formes:
 ; de la forme suivante, constituant à chaque fois un nouvel étage
 ; de transformation. Par exemple:
 (->  
-   {:a 1 :b 2} 
+   {:a 1 :b 2}
    (assoc :c 3) ;=> Génère ici (assoc {:a 1 :b 2} :c 3)
    (dissoc :b)) ;=> Génère ici (dissoc (assoc {:a 1 :b 2} :c 3) :b)
-   
+
 ; Cette expression est ré-écrite en:
 ; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
 ; et est évaluée en : {:a 1 :c 3}
@@ -302,6 +302,14 @@ ressemblent à toutes les autres formes:
    (into []))    ;=> Génère ici (into [] (filter odd? (map inc (range 10))), ce qui est évalué au final à;
                  ; [1 3 5 7 9]
 
+; Quand vous êtes dans une situation où vous voulez plus de liberté pour choisir 
+; où mettre le résultat des étages précédents, vous pouvez utiliser la
+; macro as->. Avec cette macro, donnez un nom spécifique au résultat de la transformation
+; précédente pour le placer, à votre guise, où bon vous semble dans l'étage courant:
+(as-> [1 2 3] input
+  (map inc input);=> Utilisation du résultat en dernière position
+  (nth input 4) ;=> et en deuxième position, dans la même expression
+  (conj [4 5 6] input [8 9 10])) ;=> ou au milieu !
 
 ; Modules
 ;;;;;;;;;;;;;;;
@@ -370,7 +378,7 @@ ressemblent à toutes les autres formes:
 ; STM
 ;;;;;;;;;;;;;;;;;
 
-; La mémoire logiciel transactionnelle ("Software Transactional Memory") 
+; La mémoire logiciel transactionnelle ("Software Transactional Memory")
 ; est le mécanisme que Clojure utilise pour gérer les états persistents.
 ; Il y a plusieurs formes en Clojure qui utilisent cela.
 
@@ -384,7 +392,7 @@ ressemblent à toutes les autres formes:
 (swap! my-atom assoc :a 1) ; Définit my-atom comme le résultat de (assoc {} :a 1)
 (swap! my-atom assoc :b 2) ; Définit my-atom comme le résultat de (assoc {:a 1} :b 2)
 
-; Use '@' to dereference the atom and get the value 
+; Use '@' to dereference the atom and get the value
 my-atom  ;=> Atom<#...> (Renvoie l'objet Atom)
 @my-atom ; => {:a 1 :b 2}
 
diff --git a/fr-fr/crystal-fr.html.markdown b/fr-fr/crystal-fr.html.markdown
new file mode 100644
index 00000000..2c4e3dad
--- /dev/null
+++ b/fr-fr/crystal-fr.html.markdown
@@ -0,0 +1,555 @@
+---
+language: crystal
+filename: learncrystal-fr.cr
+contributors:
+    - ["Vitalii Elenhaupt", "http://veelenga.com"]
+    - ["Arnaud Fernandés", "https://github.com/TechMagister/"]
+translators:
+    - ["Arnaud Fernandés", "http://github.com/TechMagister/"]
+lang: fr-fr
+---
+
+```crystal
+
+# Ceci est un commentaire
+
+# Tout est objet
+nil.class  #=> Nil
+100.class  #=> Int32
+true.class #=> Bool
+
+# Les valeurs fausses sont : nil, false et les pointeurs null
+!nil   #=> true  : Bool
+!false #=> true  : Bool
+!0     #=> false : Bool
+
+# Entiers
+
+1.class #=> Int32
+
+# Quatre types d'entiers signés
+1_i8.class  #=> Int8
+1_i16.class #=> Int16
+1_i32.class #=> Int32
+1_i64.class #=> Int64
+
+# Quatre types d'entiers non signés
+1_u8.class  #=> UInt8
+1_u16.class #=> UInt16
+1_u32.class #=> UInt32
+1_u64.class #=> UInt64
+
+2147483648.class          #=> Int64
+9223372036854775808.class #=> UInt64
+
+# Nombre en base binaire
+0b1101 #=> 13 : Int32
+
+# Nombre en base octale
+0o123 #=> 83 : Int32
+
+# Nombres hexadécimaux
+0xFE012D #=> 16646445 : Int32
+0xfe012d #=> 16646445 : Int32
+
+# Nombres à virgule
+
+1.0.class #=> Float64
+
+# Il y a deux types de nombres à virgule
+1.0_f32.class #=> Float32
+1_f32.class   #=> Float32
+
+1e10.class    #=> Float64
+1.5e10.class  #=> Float64
+1.5e-7.class  #=> Float64
+
+# Caractères
+
+'a'.class #=> Char
+
+# Notation octale des caractères
+'\101' #=> 'A' : Char
+
+# Notation unicode
+'\u0041' #=> 'A' : Char
+
+# Chaînes de caratères
+
+"s".class #=> String
+
+# Les chaînes de caractères sont immuables
+s = "hello, "  #=> "hello, "        : String
+s.object_id    #=> 134667712        : UInt64
+s += "Crystal" #=> "hello, Crystal" : String
+s.object_id    #=> 142528472        : UInt64
+
+# Interpolation
+"sum = #{1 + 2}" #=> "sum = 3" : String
+
+# Chaînes multilignes
+"Ceci est une chaine sur
+plusieurs lignes"
+
+# Une autre notation pour les chaînes de caratères
+# qui permet d'insérer des guillemets
+%(hello "world") #=> "hello \"world\""
+
+# Symboles
+# Ils sont immuables et réutilisables, ils sont représentés en interne par
+# un Int32. Ils sont souvent utilisés à la place des chaînes de caractères
+# quand l'identité est plus importante que le contenu
+
+:symbol.class #=> Symbol
+
+sentence = :question?     # :"question?" : Symbol
+
+sentence == :question?    #=> true  : Bool
+sentence == :exclamation! #=> false : Bool
+sentence == "question?"   #=> false : Bool
+
+# Tableaux
+
+[1, 2, 3].class         #=> Array(Int32)
+[1, "hello", 'x'].class #=> Array(Int32 | String | Char)
+
+# Un type doit être spécifié pour les tableaux vides
+[]               # Syntax error: for empty arrays use '[] of ElementType'
+[] of Int32      #=> [] : Array(Int32)
+Array(Int32).new #=> [] : Array(Int32)
+
+# Les tableaux peuvent être indexés
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] : Array(Int32)
+array[0]                #=> 1               : Int32
+array[10]               # lève l'exception IndexError
+array[-6]               # lève l'exception IndexError
+array[10]?              #=> nil             : (Int32 | Nil)
+array[-6]?              #=> nil             : (Int32 | Nil)
+
+# À partir de la fin
+array[-1] #=> 5
+
+# Avec un index de début et la taille
+array[2, 3] #=> [3, 4, 5]
+
+# Ou avec un intervalle
+array[1..3] #=> [2, 3, 4]
+
+# L'ajout à un tableau peut se faire avec l'opérateur <<
+array << 6  #=> [1, 2, 3, 4, 5, 6]
+
+# Enlève la dernière entrée
+array.pop #=> 6
+array     #=> [1, 2, 3, 4, 5]
+
+# Enlève la première entrée
+array.shift #=> 1
+array       #=> [2, 3, 4, 5]
+
+# Vérifie si un élément est présent dans le tableau
+array.includes? 3 #=> true
+
+# Syntaxe spéciale pour un tableau de chaîne de caractères ou de symboles
+%w(one two three) #=> ["one", "two", "three"] : Array(String)
+%i(one two three) #=> [:one, :two, :three]    : Array(Symbol)
+
+# Il y a une syntaxe spéciale pour les tableaux et autres types
+# du moment qu'ils définissent une méthode .new et #<<
+set = Set{1, 2, 3} #=> [1, 2, 3]
+set.class          #=> Set(Int32)
+
+# Ce qui est ci dessus est équivalent à :
+set = Set(typeof(1, 2, 3)).new
+set << 1
+set << 2
+set << 3
+
+# Tableaux associatifs
+
+{1 => 2, 3 => 4}.class   #=> Hash(Int32, Int32)
+{1 => 2, 'a' => 3}.class #=> Hash(Int32 | Char, Int32)
+
+# Un type doit être spécifié pour les tableaux associatifs vides
+{}                     # Syntax error
+{} of Int32 => Int32   # {}
+Hash(Int32, Int32).new # {}
+
+# L'accès se fait via une clé
+hash = {"color" => "green", "number" => 5}
+hash["color"]        #=> "green"
+hash["no_such_key"]  #=> Missing hash key: "no_such_key" (KeyError)
+hash["no_such_key"]? #=> nil
+
+# Vérifie l'existence d'une clé
+hash.has_key? "color" #=> true
+
+# Notation spéciale pour les clés si ce sont des symboles
+# ou chaînes de caractères
+{key1: 'a', key2: 'b'}     # {:key1 => 'a', :key2 => 'b'}
+{"key1": 'a', "key2": 'b'} # {"key1" => 'a', "key2" => 'b'}
+
+# De même que pour les tableaux simples, une syntaxe spéciale
+# existe du moment que le type définit une méthode .new et #[]=
+class MyType
+  def []=(key, value)
+    puts "do stuff"
+  end
+end
+
+MyType{"foo" => "bar"}
+
+# Ce qui est équivalent à :
+tmp = MyType.new
+tmp["foo"] = "bar"
+tmp
+
+# Intervalle
+
+1..10                  #=> Range(Int32, Int32)
+Range.new(1, 10).class #=> Range(Int32, Int32)
+
+# Ils peuvent être inclusifs ou exclusifs
+(3..5).to_a  #=> [3, 4, 5]
+(3...5).to_a #=> [3, 4]
+
+# Vérifie si un intervalle contient une valeur
+(1..8).includes? 2 #=> true
+
+# les tuples sont fixés en taille, immuables et alloués sur la pile
+{1, "hello", 'x'}.class #=> Tuple(Int32, String, Char)
+
+# L'accès peut se faire en utilisant un index
+tuple = {:key1, :key2}
+tuple[1] #=> :key2
+tuple[2] #=> syntax error : Index out of bound
+
+# Ils peuvent être scindés en plusieurs variables
+a, b, c = {:a, 'b', "c"}
+a #=> :a
+b #=> 'b'
+c #=> "c"
+
+# Les procédures ( Proc ) sont des pointeurs de fonction
+# avec un contexte optionel. Ils sont généralement créés avec
+# cette notation :
+proc = ->(x : Int32) { x.to_s }
+proc.class # Proc(Int32, String)
+# Ou en utilisant la méthode new
+Proc(Int32, String).new { |x| x.to_s }
+
+# On les invoque avec la méthode call
+proc.call 10 #=> "10"
+
+# Contrôle de flux
+
+if true
+  "if statement"
+elsif false
+  "else-if, optional"
+else
+  "else, also optional"
+end
+
+puts "if as a suffix" if true
+
+# Le si ( if ) peut être utilisé pour une déclaration
+a = if 2 > 1
+      3
+    else
+      4
+    end
+
+a #=> 3
+
+# Opérateur ternaire
+a = 1 > 2 ? 3 : 4 #=> 4
+
+# Aiguillage à l'aide du mot clé "case"
+cmd = "move"
+
+action = case cmd
+  when "create"
+    "Creating..."
+  when "copy"
+    "Copying..."
+  when "move"
+    "Moving..."
+  when "delete"
+    "Deleting..."
+end
+
+action #=> "Moving..."
+
+# Boucle
+index = 0
+while index <= 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+index = 0
+until index > 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Mais il est préférable d'utiliser #each
+(1..3).each do |index|
+  puts "Index: #{index}"
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Le type d'une variable dépend du type de l'expression
+# dans la déclaration du if
+if a < 3
+  a = "hello"
+else
+  a = true
+end
+typeof a #=> (Bool | String)
+
+if a && b
+  # ici a et b ne sont pas null
+end
+
+if a.is_a? String
+  a.class #=> String
+end
+
+# Fonctions
+
+def double(x)
+  x * 2
+end
+
+# Les fonctions et tous les blocs retournent la valeur de la dernière évaluation
+double(2) #=> 4
+
+# Les parenthèses sont optionnelle quand l'appel n'est pas ambigü
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Les arguments sont séparés par une virgule
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Toutes les méthodes on un paramètre optionel et implicite de type bloc
+# il peut être appelé avec le mot clé 'yield'
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts "hello world" }
+
+# {
+# hello world
+# }
+
+# Un bloc peut être passé à une fonction
+# Le "&" marque une référence à un bloc
+def guests(&block)
+  block.call "some_argument"
+end
+
+# Une liste d'arguments peut être donnée, qui sera convertie en tableau
+# Pour cela, utilisez l'opérateur "*"
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Si une méthode retourne un tableau, il peut être scindé
+def foods
+    ["pancake", "sandwich", "quesadilla"]
+end
+breakfast, lunch, dinner = foods
+breakfast #=> "pancake"
+dinner    #=> "quesadilla"
+
+# Par convention, toutes les méthodes qui retournent un booléen
+# finissent par un point d'interrogation
+5.even? # false
+5.odd?  # true
+
+# Si une méthode finit avec un point d'exclamation, c'est qu'elle fait une
+# opération destructrice. Quelques méthodes ont une version "!" pour faire
+# des changements et une version non-"!" pour retourner une nouvelle version
+company_name = "Dunder Mifflin"
+company_name.gsub "Dunder", "Donald"  #=> "Donald Mifflin"
+company_name  #=> "Dunder Mifflin"
+company_name.gsub! "Dunder", "Donald"
+company_name  #=> "Donald Mifflin"
+
+
+# Les classes se définissent avec le mot clé "class"
+class Human
+
+  # Une variable de classe, partagée par toutes les instances
+  @@species = "H. sapiens"
+
+  # "name" est une chaine de caratère ( String )
+  @name : String
+
+  # Constructeur basique, assigne l'argument à la variable "name"
+  # si l'age n'est pas donné, sa valeur sera de 0
+  def initialize(@name, @age = 0)
+  end
+
+  # Mutateur
+  def name=(name)
+    @name = name
+  end
+
+  # Accesseur
+  def name
+    @name
+  end
+
+  # La macro "property" va générer les deux précédentes méthodes
+  property :name
+
+  # Les accesseurs/mutateurs peuvent aussi être créés individuellement
+  getter :name
+  setter :name
+
+  # Une méthode de classe utilise "self" pour se distinguer d'une
+  # méthode d'instance. Elle ne peut être appelée qu'à partir de la classe
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+
+# Instantie une classe
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# Appelons quelques méthodes
+jim.species #=> "H. sapiens"
+jim.name #=> "Jim Halpert"
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.name #=> "Jim Halpert II"
+dwight.species #=> "H. sapiens"
+dwight.name #=> "Dwight K. Schrute"
+
+# Appel de la méthode de classe
+Human.say("Hi") #=> Affiche "Hi" et retourne nil
+
+# Les variables qui commencent par @ ont une portée d'instance
+class TestClass
+  @var = "Je suis une variable d'instance"
+end
+
+# Les variables qui commencent par @@ ont une portée de classe
+class TestClass
+  @@var = "Je suis une variable de classe"
+end
+# Les constantes commencent par une lettre majuscule
+Var = "Je suis constante"
+Var = "impossible" # Already initialized constant Var
+
+# La classe est aussi un objet
+# Les variables de classe sont partagées avec les descendants
+
+# Classe de base
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Classe dérivée
+class Worker < Human
+end
+
+Human.foo   #=> 0
+Worker.foo  #=> 0
+
+Human.foo = 2 #=> 2
+Worker.foo    #=> 0
+
+Worker.foo = 3 #=> 3
+Human.foo   #=> 2
+Worker.foo  #=> 3
+
+module ModuleExample
+  def foo
+    "foo"
+  end
+end
+
+# Inclure (include) des modules ajoute leurs méthodes aux instances
+# Étendre (extend) ajoute les méthodes à la classe
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => undefined method 'foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => undefined method 'foo' for Book
+
+
+# Gestion des exceptions
+
+# Définit un type d'exeption
+class MyException < Exception
+end
+
+# Définit une autre exception
+class MyAnotherException < Exception; end
+
+ex = begin
+   raise MyException.new
+rescue ex1 : IndexError
+  "ex1"
+rescue ex2 : MyException | MyAnotherException
+  "ex2"
+rescue ex3 : Exception
+  "ex3"
+rescue ex4 # attrape toutes les autres exceptions
+  "ex4"
+end
+
+ex #=> "ex2"
+
+```
+
+## Ressources additionnelles
+
+- [Documentation Officielle (EN)](http://crystal-lang.org/)
diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index d9bd9b48..8d98f9dc 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: fr-fr
 ---
 
-```d
+```c
 // Commençons par un classique
 module hello;
 
@@ -30,7 +30,7 @@ D est activement développé par de nombreuses personnes très intelligents, gui
 [Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
 Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
 
-```d
+```c
 import std.stdio;
 
 void main() {
@@ -54,7 +54,7 @@ void main() {
     } while(n > 0);
 
     // For et while sont très utiles, mais en D, on préfère foreach.
-    // Les deux points : '..', créent un intervalle continue de valeurs
+    // Les deux points : '..', créent un intervalle continu de valeurs
     // incluant la première mais excluant la dernière.
     foreach(i; 1..1_000_000) {
         if(n % 2 == 0)
@@ -72,10 +72,10 @@ void main() {
 }
 ```
 On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
-`union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés)
+`union` et `enum`. Ces types sont passés à la fonction par valeur (ils sont copiés)
 De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
 
-```d
+```c
 // Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
 struct LinkedList(T) {
     T data = null;
@@ -88,7 +88,7 @@ struct LinkedList(T) {
 class BinTree(T) {
     T data = null;
 
-    // Si il n'y a qu'un seul paramètre de template,
+    // S'il n'y a qu'un seul paramètre de template,
     // on peut s'abstenir de mettre des parenthèses.
     BinTree!T left;
     BinTree!T right;
@@ -140,7 +140,7 @@ une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
 la syntaxe des structures classiques (`struct.x = 7`) comme si il
 s'agissait de méthodes getter ou setter.
 
-```d
+```c
 // Considérons une classe paramétrée avec les types 'T' et 'U'
 class MyClass(T, U) {
     T _data;
@@ -152,7 +152,7 @@ class MyClass(T, U) {
     T _data;
     U _other;
 
-	// Les constructeurs s'apellent toujours 'this'.
+	// Les constructeurs s'appellent toujours 'this'.
     this(T t, U u) {
 		// Ceci va appeller les setters ci-dessous.
         data = t;
@@ -197,8 +197,8 @@ void main() {
     writefln("Later: data = %d, str = %s", mc.data, mc.other);
 }
 ```
-Avec les propriétés, on peut constuire nos setters et nos getters
-comme on le souhaite, tout en gardant un syntaxe très propre,
+Avec les propriétés, on peut construire nos setters et nos getters
+comme on le souhaite, tout en gardant une syntaxe très propre,
 comme si on accédait directement à des membres de la classe.
 
 Les autres fonctionnalités orientées objets à notre disposition
@@ -208,20 +208,20 @@ d'une seule classe et implémenter autant d'interface que voulu.
 
 Nous venons d'explorer les fonctionnalités objet du D, mais changeons
 un peu de domaine. D permet la programmation fonctionelle, avec les fonctions
-de premier ordre, les fonctions `pure` et les données immuables.
-De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter)
+de premier ordre, les fonctions `pures` et les données immuables.
+De plus, tout vos algorithmes fonctionels favoris (map, reduce, filter)
 sont disponibles dans le module `std.algorithm`.
 
-```d
+```c
 import std.algorithm : map, filter, reduce;
 import std.range : iota; // construit un intervalle excluant la dernière valeur.
 
 void main() {
-	// On veut un algorithm qui affiche la somme de la listes des carrés
+	// On veut un algorithme qui affiche la somme de la liste des carrés
 	// des entiers paires de 1 à 100. Un jeu d'enfant !
 
-	// On se content de passer des expressions lambda en paramètre à des templates.
-	// On peut fournier au template n'importe quelle fonction, mais dans notre
+	// On se contente de passer des expressions lambda en paramètre à des templates.
+	// On peut fournir au template n'importe quelle fonction, mais dans notre
 	// cas, les lambdas sont pratiques.
     auto num = iota(1, 101).filter!(x => x % 2 == 0)
                            .map!(y => y ^^ 2)
@@ -231,24 +231,24 @@ void main() {
 }
 ```
 
-Vous voyez comme on a calculé `num` comme on le ferait en haskell par exemple ?
-C'est grâce à une innvoation de D qu'on appelle "Uniform Function Call Syntax".
-Avec l'UFCS, on peut choisir d'écrire un appelle à une fonction de manière
-classique, ou comme un appelle à une méthode. Walter Brighter a écrit un
+Vous voyez qu'on a calculé `num` comme on le ferait en haskell par exemple ?
+C'est grâce à une innovation de D qu'on appelle "Uniform Function Call Syntax".
+Avec l'UFCS, on peut choisir d'écrire un appel à une fonction de manière
+classique, ou comme un appel à une méthode. Walter Brighter a écrit un
 article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
 Pour faire court, on peut appeller une fonction dont le premier paramètre
 est de type A, comme si c'était une méthode de A.
 
-J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça
+J'aime le parallélisme. Vous aimez le parallélisme ? Bien sûr que vous aimez ça.
 Voyons comment on le fait en D !
 
-```d
+```c
 import std.stdio;
 import std.parallelism : parallel;
 import std.math : sqrt;
 
 void main() {
-    // On veut calculer la racine carré de tous les nombres
+    // On veut calculer la racine carrée de tous les nombres
     // dans notre tableau, et profiter de tous les coeurs
     // à notre disposition.
     auto arr = new double[1_000_000];
diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
new file mode 100644
index 00000000..24e8c95f
--- /dev/null
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -0,0 +1,55 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+    - ["Hughes Perreault", "https://github.com/hperreault"]
+lang: fr-fr
+---
+
+
+# Programmation dynamique
+
+## Introduction
+
+La programmation dynamique est une technique très efficace pour résoudre une certaine classe de problèmes, comme nous allons le voir. L'idée est très simple, si nous avons résolu un problème avec une certaine entrée, alors nous sauvons le résultat pour pouvoir y accéder plus tard, pour éviter d'avoir à le calculer à nouveau.
+
+## Moyens de résoudre ces problèmes
+
+1.) *De haut en bas* : Commençons à résoudre le problème en le séparant en morceaux. Si nous voyons que le problème a déjà été résolu, alors nous retournons la réponse précédemment sauvegardée. Si le problème n'a pas été résolu, alors nous le résolvons et sauvegardons la réponse. C'est généralement facile et intuitif de réfléchir de cette façon. Cela s'appelle la Mémorisation.
+
+2.) *De bas en haut* : Il faut analyser le problème et trouver les sous-problèmes, et l'ordre dans lequel il faut les résoudre. Ensuite, nous devons résoudre les sous-problèmes et monter jusqu'au problème que nous voulons résoudre. De cette façon, nous sommes assurés que les sous-problèmes sont résolus avant de résoudre le vrai problème. Cela s'appelle la Programmation Dynamique.
+
+## Exemple de Programmation Dynamique
+
+Le problème de la plus grande sous-chaîne croissante est de trouver la plus grande sous-chaîne croissante dans une chaîne. Soit la chaîne `S = {a1, a2, a3, a4, ............., an-1, an}`, nous avons à trouver la plus grande chaîne telle que pour tout `j` et `i`, `j<i` dans la chaîne `aj<ai`.
+Premièrement, nous avons à trouver la valeur de la plus grande sous-chaîne (LSi) à chaque index `i`, avec le dernier élément de la sous-chaîne étant ai. Alors, la plus grande sous-chaîne sera le plus gros LSi. Pour commencer, LSi est égal à 1, car ai est le seul élément de la chaîne (le dernier). Ensuite, pour chaque `j` tel que `j<i` et `aj<ai`, nous trouvons le plus grand LSj et ajoutons le à LSi. L'algorithme fonctionne en temps *O(n2)*.   
+
+Pseudo-code pour trouver la longueur de la plus grande sous-chaîne croissante :
+La complexité de cet algorithme peut être réduite en utilisant une meilleure structure de données qu'un tableau. Par exemple, si nous sauvegardions le tableau d'origine, ou une variable comme plus_grande_chaîne_jusqu'à_maintenant et son index, nous pourrions sauver beaucoup de temps. 
+
+Le même concept peut être appliqué pour trouver le chemin le plus long dans un graphe acyclique orienté.  
+
+```python
+ for i=0 to n-1
+            LS[i]=1
+            for j=0 to i-1
+                        if (a[i] >  a[j] and LS[i]<LS[j])
+                                    LS[i] = LS[j]+1
+ for i=0 to n-1
+            if (largest < LS[i])
+```
+
+### Problèmes classiques de programmation dynamique
+
+L'algorithme de Floyd Warshall(EN)) - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
+
+Problème du sac à dos(EN) - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
+
+
+Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
+
+## Online Resources
+
+* [codechef EN](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/fr-fr/elisp-fr.html.markdown b/fr-fr/elisp-fr.html.markdown
new file mode 100644
index 00000000..2e0a9408
--- /dev/null
+++ b/fr-fr/elisp-fr.html.markdown
@@ -0,0 +1,372 @@
+---
+language: elisp
+contributors:
+    - ["Bastien Guerry", "https://bzg.fr"]
+    - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
+translators:
+    - ["Bastien Guerry", "https://bzg.fr"]
+filename: learn-emacs-lisp-fr.el
+lang: fr-fr
+---
+
+```scheme
+;; Ceci est une introduction à Emacs Lisp en 15 minutes (v0.2d)
+;;
+;; Auteur : Bastien / @bzg2 / https://bzg.fr
+;;
+;; Prenez d'abord le temps de lire ce texte en anglais de Peter Norvig :
+;; http://norvig.com/21-days.html
+;;
+;; Ensuite installez GNU Emacs 24.3 (ou une version ultérieure) :
+;;
+;; Debian : apt-get install emacs (voir les instructions pour votre distribution)
+;; MacOSX : http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg
+;; Windows : http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip
+;;
+;; Vous trouverez plus d'informations sur l'installation :
+;; http://www.gnu.org/software/emacs/#Obtaining
+
+;; Avertissement important :
+;;
+;; Suivre ce tutoriel ne risque pas d'endommager votre ordinateur,
+;; sauf si vous vous énervez au point de le jeter par terre. En tout
+;; cas, je décline toute responsabilité en cas de problème.
+;; Amusez-vous bien !
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Lancez Emacs.
+;;
+;; Tapez la touche "q" pour enlever le message d'accueil.
+;;
+;; Maintenant regardez la ligne grise au pied de la fenêtre :
+;;
+;; "*scratch*" est le nom de l'espace d'édition dans lequel vous vous
+;; trouvez. Cet espace d'édition est appelé un "buffer".
+;;
+;; Le buffer scratch est le buffer par défaut quand on ouvre Emacs.
+;; Vous n'éditez jamais de fichier directement : vous éditez des
+;; buffers que vous pouvez sauvegarder dans des fichiers.
+;;
+;; "Lisp interaction" désigne le jeu de commandes disponible ici.
+;;
+;; Emacs a un jeu de commandes par défaut pour chaque buffer, et
+;; plusieurs autres jeux de commandes disponibles quand vous activez
+;; un mode particulier.  Ici nous utilisons `lisp-interaction-mode',
+;; qui propose des commandes pour évaluer et naviguer dans du code
+;; Elisp.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Le point-virgule commence un commentaire partout sur une ligne.
+;;
+;; Les programmes Elisp sont composés d'expressions symboliques aussi
+;; appelées "sexps" :
+(+ 2 2)
+
+;; Cette expression symbolique se lit "Ajouter 2 à 2".
+
+;; Les sexps sont placées entre parenthèses, possiblement sur
+;; plusieurs niveaux :
+(+ 2 (+ 1 1))
+
+;; Une expression symbolique contient des atomes ou d'autres
+;; expressions symboliques. Dans les exemples ci-dessus, 1 et 2 sont
+;; des atomes et (+ 2 (+ 1 1)) et (+ 1 1) des expressions symboliques.
+
+;; Dans le mode `lisp-interaction-mode' vous pouvez évaluer les sexps.
+;; Placez le curseur juste après la parenthèse fermante, tenez la
+;; touche "Control" enfoncée et appuyez sur la touche "j" (soit le
+;; raccourci "C-j").
+
+(+ 3 (+ 1 2))
+;;           ^ curseur ici
+;; `C-j' => 6
+
+;; `C-j' insère le résultat de l'évaluation dans le buffer.
+
+;; `C-x C-e' affiche le même résultat dans la ligne tout en bas
+;; d'Emacs, appelée le "minibuffer". On utilise en général `C-x C-e',
+;; pour ne pas encombrer le buffer avec du texte inutile.
+
+;; `setq' assigne une valeur à une variable :
+(setq my-name "Bastien")
+;; `C-x C-e' => "Bastien" (affiché dans le minibuffer)
+
+;; `insert' va insérer "Hello!" là où se trouve le curseur :
+(insert "Hello!")
+;; `C-x C-e' => "Hello!"
+
+;; Nous utilisons `insert' avec un seul argument "Hello!", mais
+;; nous pouvons passer plus d'arguments - ici nous en passons deux :
+
+(insert "Hello" " world!")
+;; `C-x C-e' => "Hello world!"
+
+;; Vous pouvez utiliser des variables au lieu de chaînes de caractères :
+(insert "Hello, I am " my-name)
+;; `C-x C-e' => "Hello, I am Bastien"
+
+;; Vous pouvez combiner les sexps en fonctions :
+(defun hello () (insert "Hello, I am " my-name))
+;; `C-x C-e' => hello
+
+;; Vous pouvez évaluer les fonctions :
+(hello)
+;; `C-x C-e' => Hello, I am Bastien
+
+;; Les parenthèses vides dans la définition de la fonction signifient
+;; qu'elle ne prend pas d'argument. Mais toujours utiliser `my-name'
+;; est ennuyant, demandons à la fonction d'accepter un argument (ici
+;; l'argument est appelé "name") :
+
+(defun hello (name) (insert "Hello " name))
+;; `C-x C-e' => hello
+
+;; Maintenant appelons la fonction avec la chaîne de caractères "you"
+;; comme valeur de son unique argument :
+(hello "you")
+;; `C-x C-e' => "Hello you"
+
+;; Youpi!
+
+;; Faites une pause.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Maintenant ouvrez un nouveau buffer appelé "*test*" dans une
+;; nouvelle fenêtre :
+
+(switch-to-buffer-other-window "*test*")
+;; `C-x C-e'
+;; => [l'écran a deux fenêtres et le curseur est dans le buffer *test*]
+
+;; Placez la souris sur la fenêtre du haut et cliquez-gauche pour
+;; retourner dans cette fenêtre. Ou bien utilisez `C-x o' (i.e. tenez
+;; control-x appuyé et appuyez sur o) pour aller dans l'autre fenêtre
+;; interactivement.
+
+;; Vous pouvez combiner plusieurs sexps avec `progn' :
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (hello "you"))
+;; `C-x C-e'
+;; => [L'écran a deux fenêtres et le curseur est dans le buffer *test*]
+
+;; Maintenant si ça ne vous dérange pas, je vais arrêter de vous
+;; demander de faire `C-x C-e' : faites-le pour chaque sexp qui suit.
+
+;; Retournez toujours dans le buffer *scratch* avec la souris ou `C-x o'.
+
+;; Il est souvent utile d'effacer le contenu du buffer :
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "there"))
+
+;; Ou d'aller à l'autre fenêtre :
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "you")
+  (other-window 1))
+
+;; Vous pouvez associer une valeur à une variable locale avec `let' :
+(let ((local-name "you"))
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello local-name)
+  (other-window 1))
+
+;; Dans ce cas pas besoin d'utiliser `progn' puisque `let' combine
+;; aussi plusieurs sexps.
+
+;; Mettons en forme une chaîne de caractères :
+(format "Hello %s!\n" "visitor")
+
+;; %s désigne l'emplacement de la chaîne, remplacé par "visitor".
+;; \n est le caractère de saut de ligne.
+
+;; Améliorons notre fonction en utilisant "format" :
+(defun hello (name)
+  (insert (format "Hello %s!\n" name)))
+
+(hello "you")
+
+;; Créons une autre fonction qui utilise `let' :
+(defun greeting (name)
+  (let ((your-name "Bastien"))
+    (insert (format "Hello %s!\n\nI am %s."
+                    name       ; l'argument de la fonction
+                    your-name  ; la variable "let-bindée" "Bastien"
+                    ))))
+
+;; Et évaluons-la :
+(greeting "you")
+
+;; Certaines fonctions sont interactives :
+(read-from-minibuffer "Enter your name: ")
+
+;; Évaluer cette fonction va renvoyer ce que vous avez saisi dans le
+;; minibuffer.
+
+;; Faisons que notre fonction `greeting' vous demande votre nom :
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (insert (format "Hello!\n\nI am %s and you are %s."
+                    from-name ; l'argument de la fonction
+                    your-name ; la variable "let-bindée", entrée dans le minibuffer
+                    ))))
+
+(greeting "Bastien")
+
+;; Complétons la fonction pour qu'elle affiche le résultat dans
+;; l'autre fenêtre :
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (insert (format "Hello %s!\n\nI am %s." your-name from-name))
+    (other-window 1)))
+
+;; Maintenant testons :
+(greeting "Bastien")
+
+;; Faites une pause.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Stockons une liste de noms :
+(setq list-of-names '("Sarah" "Chloe" "Mathilde"))
+
+;; Récupérez le premier élément de la liste avec `car' :
+(car list-of-names)
+
+;; Récupérez tous les élements sauf le premier avec `cdr' :
+(cdr list-of-names)
+
+;; Ajoutez un élément au début avec `push' :
+(push "Stephanie" list-of-names)
+
+;; Note : `car' et `cdr' ne modifient pas la liste, mais `push' oui.
+;; C'est une différence importante : certaines fonctions n'ont pas
+;; d'effets de bord (comme `car') et d'autres oui (comme `push').
+
+;; Évaluons `hello' pour tous les éléments dans `list-of-names' :
+(mapcar 'hello list-of-names)
+
+;; Améliorons `greeting' pour dire hello aux noms de `list-of-names' :
+(defun greeting ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (mapcar 'hello list-of-names)
+    (other-window 1))
+
+(greeting)
+
+;; Vous vous souvenez de la fonction `hello' définie ci-dessus ?  Elle
+;; prend seulement un argument, un nom.  `mapcar' appelle `hello' en
+;; utilisant successivement chaque élément de `list-of-names' comme
+;; argument de `hello'.
+
+;; Maintenant arrangeons un peu ce qui est affiché dans le buffer :
+
+(defun replace-hello-by-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (search-forward "Hello")
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+;; (goto-char (point-min)) va au début du buffer.
+;; (search-forward "Hello") cherche la chaîne "Hello".
+;; (while x y) évalue la sexp(s) y tant que x renvoie quelque chose.
+;; Si x renvoie `nil' (rien), nous sortons de la boucle.
+
+(replace-hello-by-bonjour)
+
+;; Vous devriez voir toutes les occurrences de "Hello" dans le buffer
+;; *test* remplacées par "Bonjour".
+
+;; Vous devriez aussi avoir une erreur : "Search failed: Hello".
+;;
+;; Pour éviter cette erreur, il faut dire à `search-forward' si la
+;; recherche doit s'arrêter à un certain point du buffer, et si elle
+;; doit s'arrêter silencieusement si aucune chaîne n'est trouvée.
+
+;; (search-forward "Hello" nil t) fait ça :
+
+;; L'argument `nil' indique que la recherche n'est pas limitée à une
+;; position.  L'argument `t' indique de s'arrêter silencieusement si
+;; rien n'est trouvé.
+
+;; Nous utilisons cette sexp dans la fonction ci-dessous, qui ne
+;; renvoie pas d'erreur :
+
+(defun hello-to-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    ;; Dit hello aux noms de `list-of-names'
+    (mapcar 'hello list-of-names)
+    (goto-char (point-min))
+    ;; Remplace "Hello" par "Bonjour"
+    (while (search-forward "Hello" nil t)
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+(hello-to-bonjour)
+
+;; Mettons les noms en gras :
+
+(defun boldify-names ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (re-search-forward "Bonjour \\(.+\\)!" nil t)
+      (add-text-properties (match-beginning 1)
+                           (match-end 1)
+                           (list 'face 'bold)))
+    (other-window 1))
+
+;; Cette fonction introduit `re-search-forward' : au lieu de chercher
+;; la chaîne "Bonjour", nous cherchons un "pattern" en utilisant une
+;; "expression régulière" (le préfixe "re-" signifie "regular
+;; expression").
+
+;; L'expression régulière est "Bonjour \\(.+\\)!" et se lit :
+;; la chaîne "Bonjour ", et
+;; un groupe de                | c'est la syntaxe \\( ... \\)
+;;   n'importe quel caractère  | c'est le .
+;;   une ou plusieurs fois     | c'est le +
+;; et la chaîne "!".
+
+;; Prêt ?  Testons !
+
+(boldify-names)
+
+;; `add-text-properties' ajoute des propriétés textuelles telle que
+;; des "faces" (une "face" définit la fonte, la couleur, la taille et
+;; d'autres propriétés du texte.)
+
+;; Et voilà, c'est fini.  Happy hacking!
+
+;; Si vous voulez en savoir plus sur une variable ou une fonction :
+;;
+;; C-h v une-variable RET
+;; C-h f une-fonction RET
+;;
+;; Pour lire le manuel Emacs Lisp avec Emacs :
+;;
+;; C-h i m elisp RET
+;;
+;; Pour lire en ligne une introduction à Emacs Lisp :
+;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html
+
+;; Merci à ces personnes pour leurs retours et suggetions :
+;; - Wes Hardaker
+;; - notbob
+;; - Kevin Montuori
+;; - Arne Babenhauserheide
+;; - Alan Schmitt
+;; - LinXitoW
+;; - Aaron Meurer
+```
diff --git a/fr-fr/fsharp-fr.html.markdown b/fr-fr/fsharp-fr.html.markdown
new file mode 100644
index 00000000..3fd41676
--- /dev/null
+++ b/fr-fr/fsharp-fr.html.markdown
@@ -0,0 +1,631 @@
+---
+language: F#
+lang: fr-fr
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
+translators:
+    - ["Alois de Gouvello", "https://github.com/aloisdg"]
+filename: learnfsharp-fr.fs
+---
+
+F# est un langage de programmation fonctionnel et orienté objet. Il est gratuit et son code source est ouvert. Il tourne sur Linux, Mac, Windows et plus.
+
+Il possède un puissant système de type qui piège de nombreuses erreurs à la compilation, mais il utilise l'inférence de type ce qui lui permet d'être lu comme un langage dynamique.
+
+La syntaxe de F# est différente des langages héritant de C.
+
+* Les accolades ne sont pas utilisées pour délimiter les blocs de code. À la place, l'indentation est utilisée (à la manière de Python).
+* Les espaces sont utilisés pour séparer les paramètres à la place des virgules.
+
+Si vous voulez essayer le code ci-dessous, vous pouvez vous rendre sur [tryfsharp.org](http://www.tryfsharp.org/Create) et le coller dans le [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop).
+
+```fsharp
+
+// Les commentaires d'une seule ligne commencent par un double slash
+(* Les commentaires multilignes utilise les paires (* . . . *)
+
+-fin du commentaire multilignes- *)
+
+// ================================================
+// Syntaxe de base
+// ================================================
+
+// ------ "Variables" (mais pas vraiment) ------
+// Le mot clé "let" définit une valeur (immutable)
+let myInt = 5
+let myFloat = 3.14
+let myString = "hello"           // Notons qu'aucun type n'est nécessaire
+
+// ------ Listes ------
+let twoToFive = [2;3;4;5]        // Les crochets créent une liste avec
+                                 // des point-virgules pour délimiteurs.
+let oneToFive = 1 :: twoToFive   // :: crée une liste avec un nouvel élément
+// Le résultat est [1;2;3;4;5]
+let zeroToFive = [0;1] @ twoToFive   // @ concatène deux listes
+
+// IMPORTANT: les virgules ne sont jamais utilisées pour délimiter,
+// seulement les point-virgules !
+
+// ------ Fonctions ------
+// Le mot clé "let" définit aussi le nom d'une fonction.
+let square x = x * x          // Notons qu'aucune parenthèse n'est utilisée.
+square 3                      // Maitenant, exécutons la fonction.
+                              // Encore une fois, aucune parenthèse.
+
+let add x y = x + y           // N'utilisez pas add (x,y) ! Cela signifie
+                              // quelque chose de complètement différent.
+add 2 3                       // À présent, exécutons la fonction.
+
+// Pour définir une fonction sur plusieurs lignes, utilisons l'indentation.
+// Les point-virgules ne sont pas nécessaires.
+let evens list =
+   let isEven x = x%2 = 0     // Définit "isEven" comme une fonction imbriquée
+   List.filter isEven list    // List.filter est une fonction de la librairie
+                              // à deux paramètres: un fonction retournant un
+                              // booléen et une liste sur laquelle travailler
+
+evens oneToFive               // À présent, exécutons la fonction.
+
+// Vous pouvez utilisez les parenthèses pour clarifier.
+// Dans cet exemple, "map" est exécutée en première, avec deux arguments,
+// ensuite "sum" est exécutée sur le résultat.
+// Sans les parenthèses, "List.map" serait passé en argument à List.sum.
+let sumOfSquaresTo100 =
+   List.sum ( List.map square [1..100] )
+
+// Vous pouvez rediriger la sortie d'une fonction vers une autre avec "|>"
+// Rediriger des données est très commun en F#, comme avec les pipes UNIX.
+
+// Voici la même fonction sumOfSquares écrite en utilisant des pipes
+let sumOfSquaresTo100piped =
+   [1..100] |> List.map square |> List.sum  // "square" est déclaré avant
+
+// Vous pouvez définir des lambdas (fonctions anonymes) grâce au mot clé "fun"
+let sumOfSquaresTo100withFun =
+   [1..100] |> List.map (fun x -> x*x) |> List.sum
+
+// En F#, il n'y a pas de mot clé "return". Une fonction retourne toujours
+// la valeur de la dernière expression utilisée.
+
+// ------ Pattern Matching ------
+// Match..with.. est une surcharge de la condition case/switch.
+let simplePatternMatch =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x is a"
+    | "b" -> printfn "x is b"
+    | _ -> printfn "x is something else"   // underscore correspond à tout le reste
+
+// F# n'autorise pas la valeur null par défaut -- vous devez utiliser le type Option
+// et ensuite faire correspondre le pattern.
+// Some(..) et None sont approximativement analogue à des wrappers de Nullable
+let validValue = Some(99)
+let invalidValue = None
+
+// Dans cet exemple, match..with trouve une correspondance à "Some" et à "None",
+// et affiche la valeur du "Some" en même temps.
+let optionPatternMatch input =
+   match input with
+    | Some i -> printfn "input is an int=%d" i
+    | None -> printfn "input is missing"
+
+optionPatternMatch validValue
+optionPatternMatch invalidValue
+
+// ------ Affichage ------
+// Les fonctions printf/printfn sont similaires aux fonctions
+// Console.Write/WriteLine de C#.
+printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
+printfn "A string %s, and something generic %A" "hello" [1;2;3;4]
+
+// Il y a aussi les fonctions printf/sprintfn pour formater des données
+// en string. C'est similaire au String.Format de C#.
+
+// ================================================
+// Plus sur les fonctions
+// ================================================
+
+// F# est un véritable langage fonctionel -- les fonctions sont des
+// entités de premier ordre et peuvent êtres combinées facilement
+// pour créer des constructions puissantes
+
+// Les modules sont utilisés pour grouper des fonctions ensemble.
+// L'indentation est nécessaire pour chaque module imbriqué.
+module FunctionExamples =
+
+    // définit un simple fonction d'addition
+    let add x y = x + y
+
+    // usage basique d'une fonction
+    let a = add 1 2
+    printfn "1+2 = %i" a
+
+    // partial application to "bake in" parameters (?)
+    let add42 = add 42
+    let b = add42 1
+    printfn "42+1 = %i" b
+
+    // composition pour combiner des fonctions
+    let add1 = add 1
+    let add2 = add 2
+    let add3 = add1 >> add2
+    let c = add3 7
+    printfn "3+7 = %i" c
+
+    // fonctions de premier ordre
+    [1..10] |> List.map add3 |> printfn "new list is %A"
+
+    // listes de fonction et plus
+    let add6 = [add1; add2; add3] |> List.reduce (>>)
+    let d = add6 7
+    printfn "1+2+3+7 = %i" d
+
+// ================================================
+// Listes et collections
+// ================================================
+
+// Il y a trois types de collection ordonnée :
+// * Les listes sont les collections immutables les plus basiques
+// * Les tableaux sont mutables et plus efficients
+// * Les séquences sont lazy et infinies (e.g. un enumerator)
+//
+// Des autres collections incluent des maps immutables et des sets
+// plus toutes les collections de .NET
+
+module ListExamples =
+
+    // les listes utilisent des crochets
+    let list1 = ["a";"b"]
+    let list2 = "c" :: list1    // :: pour un ajout au début
+    let list3 = list1 @ list2   // @ pour la concatenation
+
+    // Compréhensions des listes (aka générateurs)
+    let squares = [for i in 1..10 do yield i*i]
+
+    //  Générateur de nombre premier
+    let rec sieve = function
+        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primes = sieve [2..50]
+    printfn "%A" primes
+
+    // le pattern matching pour les listes
+    let listMatcher aList =
+        match aList with
+        | [] -> printfn "the list is empty"
+        | [first] -> printfn "the list has one element %A " first
+        | [first; second] -> printfn "list is %A and %A" first second
+        | _ -> printfn "the list has more than two elements"
+
+    listMatcher [1;2;3;4]
+    listMatcher [1;2]
+    listMatcher [1]
+    listMatcher []
+
+    // Récursion en utilisant les listes
+    let rec sum aList =
+        match aList with
+        | [] -> 0
+        | x::xs -> x + sum xs
+    sum [1..10]
+
+    // -----------------------------------------
+    // Fonctions de la librairie standard
+    // -----------------------------------------
+
+    // map
+    let add3 x = x + 3
+    [1..10] |> List.map add3
+
+    // filtre
+    let even x = x % 2 = 0
+    [1..10] |> List.filter even
+
+    // beaucoup plus -- se référer à la documentation
+
+module ArrayExamples =
+
+    // les tableaux utilisent les crochets avec des barres
+    let array1 = [| "a";"b" |]
+    let first = array1.[0]        // accès à l'index en utilisant un point
+
+    // le pattern matching des tableaux est le même que celui des listes
+    let arrayMatcher aList =
+        match aList with
+        | [| |] -> printfn "the array is empty"
+        | [| first |] -> printfn "the array has one element %A " first
+        | [| first; second |] -> printfn "array is %A and %A" first second
+        | _ -> printfn "the array has more than two elements"
+
+    arrayMatcher [| 1;2;3;4 |]
+
+    // Fonctions de la librairie standard comme celles des listes
+    [| 1..10 |]
+    |> Array.map (fun i -> i+3)
+    |> Array.filter (fun i -> i%2 = 0)
+    |> Array.iter (printfn "value is %i. ")
+
+module SequenceExamples =
+
+    // Les séquences utilisent des accolades
+    let seq1 = seq { yield "a"; yield "b" }
+
+    // Les séquences peuvent utiliser yield et
+    // peuvent contenir des sous-sequences
+    let strange = seq {
+        // "yield" ajoute un élément
+        yield 1; yield 2;
+
+        // "yield!" ajoute une sous-sequence complète
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i%2 = 0 then yield i }}
+    // test
+    strange |> Seq.toList
+
+    // Les séquences peuvent être créées en utilisant "unfold"
+    // Voici la suite de fibonacci
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // test
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "first 10 fibs are %A" fib10
+
+// ================================================
+// Types de données
+// ================================================
+
+module DataTypeExamples =
+
+    // Toutes les données sont immutables par défaut
+
+    // Les tuples sont de simple et rapide types anonymes
+    // -- Utilisons une virgule pour créer un tuple
+    let twoTuple = 1,2
+    let threeTuple = "a",2,true
+
+    // Pattern match pour déballer
+    let x,y = twoTuple  // assigne x=1 y=2
+
+    // ------------------------------------
+    // Record types ont des champs nommés
+    // ------------------------------------
+
+    // On utilise "type" avec des accolades pour définir un type record
+    type Person = {First:string; Last:string}
+
+    // On utilise "let" avec des accolades pour créer un record (enregistrement)
+    let person1 = {First="John"; Last="Doe"}
+
+    // Pattern match pour déballer
+    let {First=first} = person1    // assigne first="john"
+
+    // ------------------------------------
+    // Union types (ou variants) ont un set (ensemble) de choix
+    // Un seul cas peut être valide à la fois.
+    // ------------------------------------
+
+    // On utilise "type" avec bar/pipe pour definir un union type
+    type Temp =
+        | DegreesC of float
+        | DegreesF of float
+
+    // On utilise un de ces choix pour en créér un
+    let temp1 = DegreesF 98.6
+    let temp2 = DegreesC 37.0
+
+    // Pattern match on all cases to unpack(?)
+    let printTemp = function
+       | DegreesC t -> printfn "%f degC" t
+       | DegreesF t -> printfn "%f degF" t
+
+    printTemp temp1
+    printTemp temp2
+
+    // ------------------------------------
+    // Types récursif
+    // ------------------------------------
+
+    // Les types peuvent être combinés récursivement de façon complexe
+    // sans avoir à créer des sous-classes
+    type Employee =
+      | Worker of Person
+      | Manager of Employee list
+
+    let jdoe = {First="John";Last="Doe"}
+    let worker = Worker jdoe
+
+    // ------------------------------------
+    // Modelling with types(?)
+    // ------------------------------------
+
+    // Les types union sont excellents pour modelling state without using flags(?)
+    type EmailAddress =
+        | ValidEmailAddress of string
+        | InvalidEmailAddress of string
+
+    let trySendEmail email =
+        match email with // utilisations du pattern matching
+        | ValidEmailAddress address -> ()   // envoyer
+        | InvalidEmailAddress address -> () // ne pas envoyer
+
+    // Combiner ensemble, les types union et les types record
+    // offrent une excellente fondation pour le domain driven design.
+    // Vous pouvez créer des centaines de petit types qui reflèteront fidèlement
+    // le domain.
+
+    type CartItem = { ProductCode: string; Qty: int }
+    type Payment = Payment of float
+    type ActiveCartData = { UnpaidItems: CartItem list }
+    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
+
+    type ShoppingCart =
+        | EmptyCart  // aucune donnée
+        | ActiveCart of ActiveCartData
+        | PaidCart of PaidCartData
+
+    // ------------------------------------
+    // Comportement natif des types
+    // ------------------------------------
+
+    // Les types natifs ont un comportement "prêt-à-l'emploi" des plus utiles, sans code à ajouter.
+    // * Immutabilité
+    // * Pretty printing au debug
+    // * Egalité et comparaison
+    // * Sérialisation
+
+    // Le Pretty printing s'utilise avec %A
+    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
+             twoTuple person1 temp1 worker
+
+    // L'égalité et la comparaison sont innés
+    // Voici un exemple avec des cartes.
+    type Suit = Club | Diamond | Spade | Heart
+    type Rank = Two | Three | Four | Five | Six | Seven | Eight
+                | Nine | Ten | Jack | Queen | King | Ace
+
+    let hand = [ Club,Ace; Heart,Three; Heart,Ace;
+                 Spade,Jack; Diamond,Two; Diamond,Ace ]
+
+    // tri
+    List.sort hand |> printfn "sorted hand is (low to high) %A"
+    List.max hand |> printfn "high card is %A"
+    List.min hand |> printfn "low card is %A"
+
+// ================================================
+// Les Active patterns
+// ================================================
+
+module ActivePatternExamples =
+
+    // F# a un type particulier de pattern matching nommé "active patterns"
+    // où le pattern peut être parsé ou détecté dynamiquement.
+
+    // "banana clips" est la syntaxe pour l'active patterns
+
+    // par exemple, on définit un "active" pattern pour correspondre à des types "character"...
+    let (|Digit|Letter|Whitespace|Other|) ch =
+       if System.Char.IsDigit(ch) then Digit
+       else if System.Char.IsLetter(ch) then Letter
+       else if System.Char.IsWhiteSpace(ch) then Whitespace
+       else Other
+
+    // ... et ensuite on l'utilise pour rendre la logique de parsing plus claire
+    let printChar ch =
+      match ch with
+      | Digit -> printfn "%c is a Digit" ch
+      | Letter -> printfn "%c is a Letter" ch
+      | Whitespace -> printfn "%c is a Whitespace" ch
+      | _ -> printfn "%c is something else" ch
+
+    // afficher une liste
+    ['a';'b';'1';' ';'-';'c'] |> List.iter printChar
+
+    // -----------------------------------------
+    // FizzBuzz en utilisant les active patterns
+    // -----------------------------------------
+
+    // Vous pouvez créer un partial matching patterns également
+    // On utilise just un underscore dans la définition, et on retourne Some si ça correspond.
+    let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
+    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+
+    // la fonction principale
+    let fizzBuzz i =
+      match i with
+      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+      | MultOf3 -> printf "Fizz, "
+      | MultOf5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // test
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Concision
+// ================================================
+
+module AlgorithmExamples =
+
+    // F# a un haut ratio signal/bruit, permettant au code de se lire
+    // presque comme un véritable algorithme
+
+    // ------ Exemple: definir une fonction sumOfSquares ------
+    let sumOfSquares n =
+       [1..n]              // 1) Prendre tous les nombres de 1 à n
+       |> List.map square  // 2) Elever chacun d'entre eux au carré
+       |> List.sum         // 3) Effectuer leur somme
+
+    // test
+    sumOfSquares 100 |> printfn "Sum of squares = %A"
+
+    // ------ Exemple: definir un fonction de tri ------
+    let rec sort list =
+       match list with
+       // Si la liste est vide
+       | [] ->
+            []                            // on retourne une liste vide
+       // si la list n'est pas vide
+       | firstElem::otherElements ->      // on prend le premier élément
+            let smallerElements =         // on extrait les éléments plus petits
+                otherElements             // on prend les restants
+                |> List.filter (fun e -> e < firstElem)
+                |> sort                   // et on les trie
+            let largerElements =          // on extrait les plus grands
+                otherElements             // de ceux qui restent
+                |> List.filter (fun e -> e >= firstElem)
+                |> sort                   // et on les trie
+            // On combine les 3 morceaux dans une nouvelle liste que l'on retourne
+            List.concat [smallerElements; [firstElem]; largerElements]
+
+    // test
+    sort [1;5;23;18;9;1;3] |> printfn "Sorted = %A"
+
+// ================================================
+// Code Asynchrone
+// ================================================
+
+module AsyncExample =
+
+    // F# inclus des fonctionnalités pour aider avec le code asynchrone
+    // sans rencontrer la "pyramid of doom"
+    //
+    // L'exemple suivant télécharge une séquence de page web en parallèle.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Récupérer le contenu d'une URL de manière asynchrone
+    let fetchUrlAsync url =
+        async {   // Le mot clé "async" et les accolades
+                  // créent un objet "asynchrone"
+            let req = WebRequest.Create(Uri(url))
+            use! resp = req.AsyncGetResponse()
+                // use! est un assignement asynchrone
+            use stream = resp.GetResponseStream()
+                // "use" déclenche automatiquement close()
+                // sur les ressources à la fin du scope
+            use reader = new IO.StreamReader(stream)
+            let html = reader.ReadToEnd()
+            printfn "finished downloading %s" url
+            }
+
+    // une liste des sites à rapporter
+    let sites = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // C'est parti!
+    sites
+    |> List.map fetchUrlAsync  // créez une liste de tâche asynchrone
+    |> Async.Parallel          // dites aux tâches de tourner en parallèle
+    |> Async.RunSynchronously  // démarrez les!
+
+// ================================================
+// .NET compatabilité
+// ================================================
+
+module NetCompatibilityExamples =
+
+    // F# peut réaliser presque tout ce que C# peut faire, et il s'intègre
+    // parfaitement avec les librairies .NET ou Mono.
+
+    // ------- Travaillez avec les fonctions des librairies existantes  -------
+
+    let (i1success,i1) = System.Int32.TryParse("123");
+    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
+
+    // ------- Implémentez des interfaces à la volée! -------
+
+    // Créer un nouvel objet qui implémente IDisposable
+    let makeResource name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s disposed" name }
+
+    let useAndDisposeResources =
+        use r1 = makeResource "first resource"
+        printfn "using first resource"
+        for i in [1..3] do
+            let resourceName = sprintf "\tinner resource %d" i
+            use temp = makeResource resourceName
+            printfn "\tdo something with %s" resourceName
+        use r2 = makeResource "second resource"
+        printfn "using second resource"
+        printfn "done."
+
+    // ------- Code orienté objet -------
+
+    // F# est aussi un véritable language OO.
+    // Il supporte les classes, l'héritage, les méthodes virtuelles, etc.
+
+    // interface avec type générique
+    type IEnumerator<'a> =
+        abstract member Current : 'a
+        abstract MoveNext : unit -> bool
+
+    // Classe de base abstraite avec méthodes virtuelles
+    [<AbstractClass>]
+    type Shape() =
+        // propriétés en lecture seule
+        abstract member Width : int with get
+        abstract member Height : int with get
+        // méthode non-virtuelle
+        member this.BoundingArea = this.Height * this.Width
+        // méthode virtuelle avec implémentation de la classe de base
+        abstract member Print : unit -> unit
+        default this.Print () = printfn "I'm a shape"
+
+    // classe concrète qui hérite de sa classe de base et surcharge
+    type Rectangle(x:int, y:int) =
+        inherit Shape()
+        override this.Width = x
+        override this.Height = y
+        override this.Print ()  = printfn "I'm a Rectangle"
+
+    // test
+    let r = Rectangle(2,3)
+    printfn "The width is %i" r.Width
+    printfn "The area is %i" r.BoundingArea
+    r.Print()
+
+    // ------- extension de méthode  -------
+
+    // Juste comme en C#, F# peut étendre des classes existantes avec des extensions de méthode.
+    type System.String with
+       member this.StartsWithA = this.StartsWith "A"
+
+    // test
+    let s = "Alice"
+    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+
+    // ------- événements -------
+
+    type MyButton() =
+        let clickEvent = new Event<_>()
+
+        [<CLIEvent>]
+        member this.OnClick = clickEvent.Publish
+
+        member this.TestEvent(arg) =
+            clickEvent.Trigger(this, arg)
+
+    // test
+    let myButton = new MyButton()
+    myButton.OnClick.Add(fun (sender, arg) ->
+            printfn "Click event with arg=%O" arg)
+
+    myButton.TestEvent("Hello World!")
+
+```
+
+## Plus d'information
+
+Pour plus de démonstration de F#, rendez-vous sur le site [Try F#](http://www.tryfsharp.org/Learn), ou suivez la série [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Apprenez en davantage à propose de F# sur [fsharp.org](http://fsharp.org/).
diff --git a/fr-fr/git-fr.html.markdown b/fr-fr/git-fr.html.markdown
new file mode 100644
index 00000000..510459fe
--- /dev/null
+++ b/fr-fr/git-fr.html.markdown
@@ -0,0 +1,583 @@
+---
+category: tool
+tool: git
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Leo Rudberg" , "http://github.com/LOZORD"]
+    - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
+translators:
+    - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"]
+filename: LearnGit-fr.txt
+lang: fr-fr
+---
+
+Git est un logiciel de contrôle de versions distribué et un système de gestion
+du code source.
+
+Il effectue sa tâche via des séries d'instantanés (snapshots) du projet, et
+travaille avec ces instantanés afin de fournir les fonctionnalités de gestion
+de version et de code source.
+
+## Concepts du versionnage
+
+### Qu'est ce que le contrôle de version ?
+
+Le contrôle de version est un système qui enregistre les changements faits sur
+un ou plusieurs fichiers au fil du temps.
+
+### Versionnage centralisé VS Versionnage distribué
+
+* Le contrôle de version centralisé se concentre sur la synchronisation, le
+suivi et la sauvegarde des fichiers.
+* Le contrôle de version distribué se focalise sur l'échange des changements.
+Chaque changement a un identifiant unique.
+* Les systèmes distribués n'ont pas de structure définie. Vous pouvez aisément
+avoir un système centralisé de type SVN, avec Git.
+
+[Informations additionnelles](http://git-scm.com/book/fr/v1/D%C3%A9marrage-rapide-%C3%80-propos-de-la-gestion-de-version)
+
+### Pourquoi utiliser Git ?
+
+* Fonctionne hors ligne.
+* Travailler avec les autres devient facile !
+* Ramifier le travail (créer des branches différentes) est facile !
+* Fusionner le travail est facile !
+* Git est rapide.
+* Git est flexible.
+
+## Architecture Git
+
+
+### Dépôt ("repository")
+
+Un ensemble de fichiers, dossiers, historiques de modifications, commits
+(validations de changements) et de heads (état courant, "tête").
+Représentez-vous ceci comme une structure de données de code source, avec la
+particularité que chaque "élement" vous donne, entre autres, accès à son
+historique des révisions.
+
+Un dépôt Git comprend un répertoire .git et "l'arbre de travail" (working tree).
+
+### Répertoire .git (composant du dépôt)
+
+Le répertoire .git contient toutes les configurations, logs (journaux),
+branches, HEAD et plus.
+[Liste détaillée (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Arbre de travail (composant du dépôt)
+
+Il s'agit de l'ensemble des répertoires et fichiers de votre dépôt. Il est
+souvent qualifié de répertoire de travail ("working directory").
+
+### Index (composant du répertoire .git)
+
+L'index est la zone de transit ("staging area") dans Git. Il s'agit d'une couche
+séparant votre arbre de travail de votre dépôt Git. Ceci donne aux développeurs
+plus de pouvoir sur ce qu'ils envoient au dépôt.
+
+### Commit
+
+Un "commit" (validation de changements) est un instantané d'un ensemble de
+modifications de votre arbre de travail. Par exemple, si vous avez rajouté 5
+fichiers et enlevé 2 autres, ces changements seront contenus dans un commit
+(ou "snapshot", instantané). Ce commit peut ensuite être poussé ("pushed") dans
+d'autres dépôts, ou non !
+
+### Branches
+
+Une branche consiste essentiellement en un pointeur vers le dernier commit que
+vous avez fait. Au fur et à mesure de vos commits, ce pointeur se mettra
+automatiquement à jour pour pointer vers le dernier commit.
+
+### Etiquette ("tag")
+
+Une étiquette est une marque sur un point spécifique de l'historique.
+Typiquement, on utilise cette fonctionnalité pour marquer les états de
+publication (v1.0, et ainsi de suite).
+
+### HEAD and head (composant du répertoire .git)
+
+HEAD est un pointeur pointant vers la branche courante. Un dépôt ne peut avoir
+qu'un seul HEAD *actif*.
+head est un pointeur pouvant pointer sur n'importe quel commit. Un dépôt peut
+avoir un nombre illimité de heads.
+
+### Les états dans Git
+* Modifié - Des changements on été faits à un fichier mais ce dernier n'a pas
+encore été rajouté à l'ensemble des fichiers Git
+* Indexé ("staged") - Indique qu'un fichier modifié ira dans le prochain commit
+* Validé ("committed") - Les fichiers ont été validés dans l'ensemble de
+fichiers
+
+### Ressources conceptuelles
+
+* [Git pour les informaticiens (EN)](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git pour les designers (EN)](http://hoth.entp.com/output/git_for_designers.html)
+
+
+## Commandes
+
+
+### init
+
+Créé un dépôt Git vide. Les paramètres du dépôt Git, les informations stockées
+et plus sont dans un répertoire (un dossier) nommé ".git".
+
+```bash
+$ git init
+```
+
+### config
+
+Configuration des paramètres. Que ce soit pour le dépôt, le système lui-même,
+ou la configuration globale (le fichier de configuration globale
+est `~/.gitconfig`).
+
+
+```bash
+# Lit et assigne quelques variables (globales) de configuration de base
+$ git config --global user.email "monEmail@foo.com"
+$ git config --global user.name "Mon nom"
+```
+
+[Apprenez-en plus à propos de git config.](https://git-scm.com/book/fr/v1/Personnalisation-de-Git-Configuration-de-Git)
+
+### help
+
+Vous donne un accès rapide à un guide extrêmement détaillé de chaque commande.
+Ou juste vous donner un rappel rapide de la sémantique.
+
+```bash
+# Vérifie rapidement les commandes disponibles
+$ git help
+
+# Vérifie toutes les commandes disponibles
+$ git help -a
+
+# Aide pour une commande spécifique - manuel utilisateur
+# git help <command_here>
+$ git help add
+$ git help commit
+$ git help init
+# ou git <command_here> --help
+$ git add --help
+$ git commit --help
+$ git init --help
+```
+
+### ignorer des fichiers
+
+Ne plus suivre certains fichiers et dossiers de Git.
+Habituellement fait pour les fichiers privés et temporaires qui seraient,
+autrement, partagés dans le dépôt.
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "cle_privee" >> .gitignore
+```
+
+### status
+
+Montre les différences entre le fichier indexé (typiquement votre copie/dépôt
+de travail) et le HEAD actuel.
+
+
+```bash
+# Affiche la branche, les fichiers non suivis, les changements et autres
+différences
+$ git status
+
+# Pour en apprendre plus sur git status
+$ git help status
+```
+
+### add
+
+Rajoute des fichiers à la zone d'index. Si vous ne faites pas `git add` sur les
+nouveaux fichiers, ils ne seront pas inclus dans les commits !
+
+```bash
+# rajoute un fichier dans votre répertoire de travail actuel
+$ git add HelloWorld.java
+
+# rajoute un fichier dans un répertoire imbriqué
+$ git add /path/to/file/HelloWorld.c
+
+# Gestion des expressions régulières !
+$ git add ./*.java
+```
+
+On ne fait que rajouter des fichiers dans la zone d'index, on ne valide pas
+les changements au répertoire/dépôt de travail.
+
+### branch
+
+Gère vos branches. Vous pouvez voir, éditer, créer et supprimer des branches en
+utilisant cette commande.
+
+```bash
+# Liste les branches existantes et distantes
+$ git branch -a
+
+# Créé une nouvelle branche
+$ git branch maNouvelleBranche
+
+# Supprime une branche
+$ git branch -d maBranche
+
+# Renomme une branche
+# git branch -m <anciennom> <nouveaunom>
+$ git branch -m nomDeMaBranche nouveauNomDeMaBranche
+
+# Edite la description d'une branche
+$ git branch nomDeMaBranche --edit-description
+```
+
+### tag
+
+Gère vos étiquettes
+
+```bash
+# Liste les étiquettes
+$ git tag
+
+# Créé une étiquette annotée
+# L'option -m spécifie un message qui sera stockée dans l'étiquette.
+# Si vous ne spécifiez pas de message pour une étiquette annotée,
+# Git lance votre éditeur pour que vous puissiez le saisir.
+$ git tag -a v2.0 -m 'ma version 2.0'
+
+# Affiche des informations à propos de l'étiquette
+# comprenant des informations sur l'auteur, la date du commit correspondant,
+# et le message d'annotation avant d'afficher les informations du commit.
+$ git show v2.0
+
+# Pousse une seule étiquette dans le dépôt distant
+$ git push origin v2.0
+
+# Pousse beaucoup d'étiquettes dans le dépôt distant
+$ git push origin --tags
+```
+
+### checkout
+
+Met à jour tous les fichiers dans l'arbre de travail afin de correspondre à la
+version de la zone d'index ou de l'arbre spécifié.
+
+```bash
+# Obtenir une copie de travail du dépôt - par défaut on prend la branche master
+$ git checkout
+
+# Bascule vers une branche spéficiée
+$ git checkout nomDeLaBranche
+
+# Créé une nouvelle branche et bascule sur celle-ci
+# Revient à faire "git branch <name>; git checkout <name>"
+$ git checkout -b nouvelleBranche
+```
+
+### clone
+
+Clone (ou copie) un dépôt existant dans un nouveau répertoire. Rajoute
+également les branches distantes pour chaque branche du dépôt clôné, ce qui
+vous permet de pousser vers une branche distante.
+
+```bash
+# Clone learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+
+# Clone superficiel ("shallow clone") - clone plus rapide qui récupère
+seulement le dernier instantané ("snapshot")
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+
+# Clone seulement une branche spécifique
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
+```
+
+### commit
+
+Conserve le contenu actuel de la zone d'index dans un nouveau "commit." Ce
+commit contient les changements faits, accompagnés d'un message écrit par son
+auteur.
+
+```bash
+# Commit avec un message
+$ git commit -m "Ajout de la fonction multiplierNombres() dans HelloWorld.c"
+
+# Rajoute automatiquement dans l'index les fichiers modifiés ou supprimés,
+# à l'exception des nouveaux fichiers, puis commit
+$ git commit -a -m "Modification de foo.php et suppression de bar.php"
+
+# Change le dernier commit (ceci supprime le commit précédent avec un
+# nouveau commit)
+$ git commit --amend -m "Message corrigé"
+```
+
+### diff
+
+Montre les différences entre un fichier dans le répertoire de travail, la zone
+d'index and les commits.
+
+```bash
+# Affiche les différences entre votre répertoire de travail et l'index
+$ git diff
+
+# Affiche les différences entre l'index et le plus récent commit.
+$ git diff --cached
+
+# Affiche les différences entre votre répertoire de travail et le plus récent
+# commit
+$ git diff HEAD
+```
+
+### grep
+
+Permet de faire une recherche rapide dans le dépôt.
+
+Configurations optionnelles :
+
+```bash
+# Merci à Travis Jeffery pour ce qui suit
+# Affiche les numéros des lignes dans les résultats de la recherche grep
+$ git config --global grep.lineNumber true
+
+# Rend les résultats de recherche plus lisibles, en incluant les groupements
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Recherche de "nomDeVariable" dans tous les fichiers java
+$ git grep 'nomDeVariable' -- '*.java'
+
+# Recherche une ligne contenant "nomDeTableau", et "rajouter" ou "enlever"
+$ git grep -e 'nomDeTableau' --and \( -e rajouter -e enlever \)
+```
+
+Google est votre ami; pour plus d'exemples :
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Affiche les commits d'un dépôt.
+
+```bash
+# Montre tous les commits
+$ git log
+
+# Montre seulement les messages de commits et leur référence
+$ git log --oneline
+
+# Montre seulement les commits commits des merges (fusions)
+$ git log --merges
+```
+
+### merge
+
+Fusionne les changements provenant de commits externes dans la branche
+courante.
+
+```bash
+# Fusionne la branche spécifiée dans la branche courante.
+$ git merge nomDeBranche
+
+# Génère toujours un commit quand on fusionne
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Renomme ou déplace un fichier
+
+```bash
+# Renomme un fichier
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Déplace un fichier
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Force le renommage ou le déplacement
+# Si "fichierExistant" existe déjà dans le répertoire, il sera écrasé
+$ git mv -f monFichier fichierExistant
+```
+
+### pull
+
+Récupère la version d'un dépôt et la fusionne avec une autre branche.
+
+```bash
+# Met à jour votre dépôt local en y intégrant les changements
+# depuis la branche "master" du dépôt distant "origin".
+# git pull <remote> <branch>
+$ git pull origin master
+
+# Par défaut, git pull mettra à jour votre branche actuelle
+# en y intégrant les nouveaux changements venant de sa branche distante suivie
+$ git pull
+
+# Intègre les changements de la branche distante et "rebase"
+# les commits de la branche dans votre dépôt local, comme ceci:
+#"git pull <remote> <branch>, git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Pousse et fusionne les changements d'une dépôt local vers une branche distante.
+
+```bash
+# Pousse et fusionne les changements d'un dépôt local vers la branche
+# appelée "master" du dépôt distant "master".
+# git push <remote> <branch>
+$ git push origin master
+
+# Par défaut, git push poussera et fusionnera les changements de la branche
+# courante vers sa branche distante suivie.
+$ git push
+
+# Pour faire le lien entre la branche locale courante et sa branche distante,
+# rajouter l'option -u :
+$ git push -u origin master
+# Dorénavant, à chaque fois que vous voulez pousser depuis cette même branche
+# locale, utilisez ce raccourci :
+$ git push
+```
+
+### stash
+
+Sauvegarde ("stash") l'état actuel de votre espace de travail et le garde dans
+pile de changements non finis que vous pouvez réappliquer n'importe quand.
+
+Supposons que vous avez effectué du travail dans votre dépôt git, mais que vous
+voulez récupérer la version de la branche distante. Depuis que vous avez des
+changements "malpropres" (non commités) à quelques fichiers, vous ne pouvez pas
+faire de `git pull`. A la place, vous pouvez utiliser `git stash` afin de
+sauvegarder votre travail dans la pile !
+
+```bash
+$ git stash
+Saved working directory and index state \
+  "WIP on master: 049d078 added the index file"
+  HEAD is now at 049d078 added the index file
+  (To restore them type "git stash apply")
+```
+
+Vous pouvez maintenant pull !
+
+```bash
+git pull
+```
+`...changes apply...`
+
+Vérifiez maintenant que tout est OK
+
+```bash
+$ git status
+# On branch master
+nothing to commit, working directory clean
+```
+
+Vous pouvez constater quels "morceaux" vous avez stash jusque là en
+utilisant `git stash list`.
+Puisque les changements sont gardés dans une pile Last-In-First-Out, notre
+changement le plus récent sera en premier.
+
+```bash
+$ git stash list
+stash@{0}: WIP on master: 049d078 rajout du fichier index
+stash@{1}: WIP on master: c264051 annulation de "rajout de la taille_fichier"
+stash@{2}: WIP on master: 21d80a5 ajout des chiffres aux logs
+```
+
+Appliquons maintenant les changements en les enlevant de notre pile.
+
+```bash
+$ git stash pop
+# On branch master
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   index.html
+#      modified:   lib/simplegit.rb
+#
+```
+
+`git stash apply` effectue le même travail
+
+Vous êtes maintenant prêt à retourner sur vos tâches de travail !
+
+[Lecture additionelle.](https://git-scm.com/book/fr/v1/Utilitaires-Git-Le-remisage)
+
+### rebase (attention)
+
+Prend tous les changements qui ont été commités sur une branche, et les
+ré-applique sur une autre branche.
+*Ne rebasez pas les commits que vous avez poussés sur un dépôt publique*.
+
+```bash
+# Expérimentation d'un rebase dans la branche "master"
+# git rebase <basebranch> <topicbranch>
+$ git rebase master brancheExperience
+```
+
+[Lecture additionelle.](https://git-scm.com/book/fr/v1/Les-branches-avec-Git-Rebaser)
+
+### reset (attention)
+
+Réinitialise le pointeur HEAD courant à l'état spécifié. Ceci vous permet
+d'annuler des fusions, des pulls, commits, ajouts et autres. C'est une commande
+puissante mais également dangereuse si vous ne savez pas ce que vous faites.
+
+```bash
+# Réinitialise la zone d'index afin de correspondre au dernier commit (laisse
+# le répertoire inchangé).
+$ git reset
+
+# Réinitialise la zone d'index afin de correspondre au dernier commit et
+# réécrit le répertoire de travail.
+$ git reset --hard
+
+# Déplace le pointeur de la branche courante au commit spécifié (laisse
+# le répertoire inchangé). Tous les changements existents toujours dans
+# le répertoire.
+$ git reset 31f2bb1
+
+# Déplace le pointeur de la branche courante en arrière, au commit spécifié
+# et fait correspondre le répertoire de travail (supprime les changements
+# non commités et tous les commits après le commit spécifié).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Le contraire de git add, git rm supprime les fichiers de l'arbre de travail
+courant.
+
+```bash
+# Supprime HelloWorld.c
+$ git rm HelloWorld.c
+
+# Enlève un fichier d'un répertoire imbriqué.
+$ git rm /chemin/vers/le/fichier/HelloWorld.c
+```
+
+## Informations complémentaires
+
+* [tryGit - A fun interactive way to learn Git (EN)](http://try.github.io/levels/1/challenges/1)
+
+* [Udemy Git Tutorial: A Comprehensive Guide (EN)](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)
+
+* [git-scm - Tutoriaux vidéos](http://git-scm.com/videos)
+
+* [git-scm - Documentation](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutoriaux et Workflows](https://www.atlassian.com/git/)
+
+* [SalesForce Cheat Sheet (EN)](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+
+* [GitGuys (EN)](http://www.gitguys.com/)
+
+* [Git - the simple guide (EN)](http://rogerdudler.github.io/git-guide/index.html)
+
+* [Livre Pro Git](http://www.git-scm.com/book/fr/v1)
+
+* [Une introduction à Git et GitHub pour les débutants (tutoriel) (EN)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
index d9d3151f..a34dc098 100644
--- a/fr-fr/haskell.html.markdown
+++ b/fr-fr/haskell.html.markdown
@@ -66,7 +66,7 @@ not False -- True
 
 
 ----------------------------------------------------
--- Listes et tuples
+-- 2. Listes et tuples
 ----------------------------------------------------
 
 -- Tous les éléments d'une liste doit avoir le même type.
diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index f1977dac..faa22863 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -190,7 +190,7 @@ someNinthVar; // = 9
 
 // Il y a des raccourcis pour les opérations mathématiques:
 someVar += 5; // équivalent pour someVar = someVar + 5;
-someVar *= 10; // de même, someVar = someVar * 100;
+someVar *= 10; // de même, someVar = someVar * 10;
 someVar++;    // = someVar += 1;
 someVar--;  // = someVar -= 1;
 
diff --git a/fr-fr/jquery-fr.html.markdown b/fr-fr/jquery-fr.html.markdown
new file mode 100644
index 00000000..1842e02b
--- /dev/null
+++ b/fr-fr/jquery-fr.html.markdown
@@ -0,0 +1,142 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+    - ["Sylvain Vaure", "https://github.com/Gnomino"]
+filename: jquery-fr.js
+lang: fr-fr
+---
+
+jQuery est une bibliothèque JavaScript dont le but est de permettre de "faire plus en écrivant moins" (do more, write less). Elle facilite l'écriture de nombreuses fonctions, notamment au niveau d'AJAX, de la gestion d'événements, ou encore de la manipulation de documents. 
+C'est pourquoi aujourd'hui, jQuery est utilisée par de nombreuses grandes entreprises et par des développeurs du monde entier.
+
+Étant donné que jQuery est une bibliothèque JavaScript, vous devriez d'abord [apprendre le JavaScript](https://learnxinyminutes.com/docs/fr-fr/javascript-fr/)
+```js
+
+
+///////////////////////////////////
+// 1. Les sélecteurs
+
+// On utilise les sélecteurs de jQuery pour sélectionner des éléments
+var page = $(window); // Sélectionne tout le viewport
+
+// On peut aussi utiliser des sélecteurs CSS
+var paragraph = $('p'); // Sélectionne tous les éléments paragraphes
+var table1 = $('#table1'); // Sélectionne l'élément qui a l'id 'table1'
+var squares = $('.square'); // Sélectionne tous les éléments avec la classe 'square'
+var square_p = $('p.square') // Sélectionne tous les paragraphes avec la classe 'square'
+
+
+///////////////////////////////////
+// 2. Événements et effets
+// jQuery gère très bien ce qui se passe lorsqu'un événement est déclenché
+// L'événement 'ready' est très souvent utilisé sur le document
+// On utilise la méthode 'ready' pour attendre que l'élément ait fini de se charger
+$(document).ready(function(){
+  // Ce code ne s'exécutera pas avant que le document soit chargé (prêt)
+});
+// On peut aussi utiliser des fonctions définies
+function onAction() {
+  // Ceci est exécuté quand l'événement est déclenché
+}
+$('#btn').click(onAction); // Appelle onAction à chaque clic
+
+function onAction() {
+  // Ceci est exécuté quand un évènement est déclenché
+}
+
+// D'autres évènements communs :
+$('#btn').dblclick(onAction); // Double clic
+$('#btn').hover(onAction); // Survol de la souris
+$('#btn').focus(onAction); // Gain du focus
+$('#btn').blur(onAction); // Perte du focus
+$('#btn').submit(onAction); // Envoi (d'un formulaire)
+$('#btn').select(onAction); // Quand un élement est sélectionné
+$('#btn').keydown(onAction); // Quand une touche est enfoncée
+$('#btn').keyup(onAction); // Quand une touche est relâchée
+$('#btn').keypress(onAction); // Quand on appuie sur un touche
+$('#btn').mousemove(onAction); // Quand la souris se déplace
+$('#btn').mouseenter(onAction); // La souris entre dans l'élément
+$('#btn').mouseleave(onAction); // La souris sort de l'élément
+
+// On peut aussi utiliser des fonctions lambdas
+$('#btn').hover(function(){
+  // exécuté lors d'un survol de la souris
+});
+
+// Il est possible de déclencher l'événement sans le gérer
+// simplement en ne passant aucun paramètre à la méthode
+$('#btn').dblclick(); // Simule un double clic sur l'élément
+
+// On peut gérer plusieurs événements en utilisant le sélecteur une seule fois
+$('#btn').on(
+  {dblclick: myFunction1} // Déclenché à chaque double clic
+  {blur: myFunction1} // Déclenché quand l'élément perd le focus
+);
+
+// On peut déplacer et cacher des éléments grâce à des fonctions d'effets
+$('.table').hide(); // Cache le(s) élément(s)
+
+// Note: même avec un appel à une fonction dans ces méthodes 
+// cache quand même l'élément
+$('.table').hide(function(){
+    // L'élément est caché, puis la fonction est exécutée
+});
+
+// On peut stocker des sélecteurs dans des variables
+var tables = $('.table');
+
+// Des méthodes basique de manipulation de document :
+tables.hide(); // Cache un(des) élément(s)
+tables.show(); // Montre (dé-cache) un(des) élément(s)
+tables.toggle(); // Change le statut le statut caché/montré
+tables.fadeOut(); // Fait disparaître l'élément
+tables.fadeIn(); // Fait apparaître l'élément
+tables.fadeToggle(); // Fait apparaître ou disparaître
+tables.fadeTo(0.5); // Fondu jusqu'à une certaine opacité (entre 0 et 1)
+tables.slideUp(); // Cache l'élément avec un effet de glissement vers le haut
+tables.slideDown(); // Fait apparaître l'élément avec un glissement vers le bas
+tables.slideToggle(); // Cache/Montre l'élément avec un effet de glissement
+
+// Les méthodes ci-dessus prennent en arguments 
+// une vitesse (millisecondes) et une function callback
+tables.hide(1000, myFunction); // Animation d'une seconde, puis appel à la fonction
+
+// fadeTo doit avoir une opacité entre 0 et 1 comme deuxième argument
+tables.fadeTo(2000, 0.1, myFunction); // 2 sec. fade to 0.1 opacity then function
+
+// La méthode animate permet des animations légèrement plus poussées
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// La méthode prend un objet de css et de valeurs finales,
+// des paramètres d'options facultatifs pour régler l'animation,
+// et bien sûr la fonction callback
+
+///////////////////////////////////
+// 3. Manipulation
+
+// Ces méthodes sont similaires aux effets mais permettent d'aller plus loin
+$('div').addClass('taming-slim-20'); // Ajoute la classe taming-slim-20 aux div 
+
+// Méthodes ordinaires de manipulation
+$('p').append('Hello world'); // Ajoute à la fin de l'élément
+$('p').attr('class'); // Renvoie la valeur de l'attribut
+$('p').attr('class', 'content'); // Change la valeur de l'attribut
+$('p').hasClass('taming-slim-20'); // Renvoie vrai si l'élément est de la classe
+$('p').height(); // Renvoie la hauteur de l'élément ou la change
+
+
+// Pour beaucoup de méthodes de manipulation, récupérer des informations
+// d'un élément renverra SEULEMENT ceelles du premier
+$('p').height(); // Renvoie SEULEMENT la hauteur du premier élément 'p'
+
+// On peut utiliser 'each' pour parcourir tous les éléments
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Ajoute la hauteur de tous les éléments 'p' à la liste
+});
+
+
+``
+
diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 5a1e03e7..48d24549 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -1,9 +1,9 @@
 ---
 language: make
 contributors:
-	- ["Robert Steed", "https://github.com/robochat"]
+    - ["Robert Steed", "https://github.com/robochat"]
 translators:
-	- ["altaris", "https://github.com/altaris"]
+    - ["altaris", "https://github.com/altaris"]
 filename: Makefile-fr
 lang: fr-fr
 ---
diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index 66f0efbe..2e4e8461 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -62,8 +62,8 @@ __Celui-là aussi.__
 **_Pareil ici_**
 *__Et là!__*
 
-<!-- Dans le "Github Flavored Markdown", utilisé pour interpréter le Markdown 
-sur Github, on a également le strikethrough ( texte barré ) : -->
+<!-- Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown 
+sur GitHub, on a également le strikethrough ( texte barré ) : -->
 
 ~~Ce texte est barré avec strikethrough.~~
 
@@ -172,7 +172,7 @@ fonctionne aussi à l'intérieur du bloc de code -->
 
 La fonction `run()` ne vous oblige pas à aller courir!
 
-<!-- Via Github Flavored Markdown, vous pouvez utiliser 
+<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
 des syntaxes spécifiques -->
 
 \`\`\`ruby 
@@ -183,7 +183,7 @@ puts "Hello world!"
 end
 \`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
 
-<-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github 
+<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
 va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
 
 <!-- Ligne Horizontale (<hr />) -->
@@ -264,7 +264,7 @@ Pour taper *ce texte* entouré d'astérisques mais pas en italique :
 Tapez \*ce texte\*.
 
 <!-- Tableaux -->
-<!-- les Tableaux ne sont disponibles que dans le Github Flavored Markdown
+<!-- les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown
  et c'est ce n'est pas super agréable d'utilisation. 
  Mais si vous en avez besoin :
  -->
diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index 4e31c4bf..fbe1741e 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -1,5 +1,4 @@
 ---
-
 language: Objective-C
 contributors:
     - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
@@ -9,7 +8,6 @@ translators:
     - ["Yannick Loriot", "https://github.com/YannickL"]
 filename: LearnObjectiveC-fr.m
 lang: fr-fr
-
 ---
 
 L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
@@ -519,6 +517,7 @@ __unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'es
 // l'objet est supprimé
 
 ```
+
 ##  Lectures Complémentaires
 
 [La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
diff --git a/fr-fr/ruby-ecosystem-fr.html.markdown b/fr-fr/ruby-ecosystem-fr.html.markdown
new file mode 100644
index 00000000..edc69068
--- /dev/null
+++ b/fr-fr/ruby-ecosystem-fr.html.markdown
@@ -0,0 +1,155 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+    - ["Jon Smock", "http://github.com/jonsmock"]
+    - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+    - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"]
+    - ["Sylvain Abélard", "http://github.com/abelards"]
+lang: fr-fr
+
+---
+
+Les gens utilisant Ruby adoptent généralement un gestionnaire pour installer
+différentes versions de Ruby, gérer leurs paquets (ou gems), et gérer les
+dépendances des gems.
+
+## Ruby Managers
+
+Quelques plateformes possèdent Ruby pré-installé ou disponible en tant que
+paquet. La plupart des rubyistes ne les utilisent pas, ou si c'est le cas, ne
+les utilisent que pour faire démarrer un autre installateur ou implémentation de
+Ruby. Les rubyistes tendent plutôt à installer un gestionnaire en Ruby pour installer
+et changer entre les différentes et nombreuses versions de Ruby et les
+environnements de leurs projets Ruby.
+
+Les gestionnaires d'environnement Ruby les plus populaires sont :
+
+* [RVM](https://rvm.io/) - Installe et navigue entre les rubies. RVM possède
+  églement le concept des gemsets pour isoler les environnements de projets
+  complètement.
+* [ruby-build](https://github.com/sstephenson/ruby-build) - Installe seulement
+  les rubies. Utilisez-le pour un contrôle plus fin des installations des
+  rubies.
+* [rbenv](https://github.com/sstephenson/rbenv) - Navigue seulement entre les
+  rubies. Utilisé avec ruby-build. Utilisez-le pour un contrôle plus fin des
+  chargements des rubies.
+* [chruby](https://github.com/postmodern/chruby) - Navigue seulement entre les
+  rubies. Similaire à rbenv. Neutre sur comment les rubies sont installés.
+
+## Versions de Ruby
+
+Ruby a été créé par Yukihiro "Matz" Matsumoto, qui reste quelque peu un
+[BDFL](https://fr.wikipedia.org/wiki/Benevolent_Dictator_for_Life), bien que
+cela soit récemment en changement. Jusqu'à la standardisation du langage en
+2011, l'implémentation de référence de Ruby était appelé MRI (Matz' Reference
+Implementation).
+
+Les trois versions majeures de Ruby actuellement utilisées sont :
+
+* 2.0.0 - Sortie en février 2013. La plupart des bibliothèques et frameworks
+  gèrent la versions 2.0.0.
+* 1.9.3 - Sortie en octobre 2011. Il s'agit de la version que la majorité des
+  rubyists utilisent actuellement. [Fin de vie](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
+* 1.8.7 - Sortie en juin 2006. [Fin de vie](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+Les changements entre 1.8.7 et 1.9.x sont bien plus grands qu'entre 1.9.3
+et 2.0.0. Par exemple, les versions 1.9 ont introduit le support des
+encodages et d'une VM bytecode ([YARV](https://fr.wikipedia.org/wiki/YARV)).
+Il y a toujours des projets sur 1.8.7, mais ils deviennent minoritaires, étant
+donné que la majorité de la communauté a migré vers au moins 1.9.2 ou 1.9.3.
+
+## Implémentations Ruby
+
+L'écosystème Ruby comprend de nombreuses implémentations de Ruby, chacune avec
+des points forts uniques et différents degrés de compatibilité. Les différentes
+implémentations sont écrites dans différents languages.
+Chaque implémentation a des "hooks" et des fonctionnalités spécifiques, elles
+exécutent cependant très bien des fichiers Ruby classiques.
+Par exemple, JRuby est écrit en Java, mais vous n'avez pas besoin de connaître
+le Java pour l'utiliser.
+
+Très mature/compatible:
+
+* [MRI](https://github.com/ruby/ruby) - Ecrite en C, c'est l'implémentation de
+  référence de Ruby. Elle est par définition 100% compatible (avec elle-même).
+  Tous les autres rubies maintiennent la compatibilité avec MRI
+  (voir [RubySpec](#rubyspec) à la suite).
+* [JRuby](http://jruby.org/) - Écrite en Java et Ruby, cette robuste
+  implémentation est assez rapide.
+  La force de JRuby réside surtout sur l'interopérabilité JVM/Java, faisant
+  levier sur des outils JVM, des projets et des langages existants.
+* [Rubinius](http://rubini.us/) - Ecrite principalement en Ruby avec une VM
+  bytecode en C++. Egalement mature et rapide. Etant donné qu'elle est
+  implémentée en Ruby, elle couvre beaucoup de fonctionnalités de la
+  VM dans Ruby.
+
+Mpyennement mature/compatible:
+
+* [Maglev](http://maglev.github.io/) - Basée sur Gemstone, une VM Smalltalk.
+  Smalltalk possède quelques outils impressionnants, et ce projet tente
+  de les apporter dans le développement Ruby.
+* [RubyMotion](http://www.rubymotion.com/) - Ruby pour développement iOS et Android.
+* [Opal](http://opalrb.org/) - Compile le Ruby en Javascript
+
+Les implémentations de Ruby peuvent avoir leurs propres numéros de versions,
+mais elles ciblent toujours une versions spéficique de MRI pour la
+compatibilité.
+Beaucoup d'implémentations ont la capacité d'entrer dans différents modes
+(par exemple, la version 1.8 ou 1.9) afin de spécifier quelle version de MRI
+cibler.
+
+Une liste non exhaustive d'implémentations peut être trouvée [ici (EN)](https://github.com/cogitator/ruby-implementations/wiki/List-of-Ruby-implementations).
+
+## RubySpec
+
+La plupart des implémentations Ruby s'appuient fortement sur [RubySpec](http://rubyspec.org/).
+Ruby n'a pas de spécification officielle, c'est pourquoi la commaunité a écrit
+des spécifications exécutables en Ruby pour tester la compatibilité de leur
+implémentation avec MRI.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) est un gestionnaire de paquets communautaire
+pour Ruby.
+RubyGems est livré avec Ruby, il n'y a donc pas besoin de le télécharger
+séparément.
+
+Les paquets Ruby sont appelés des "gems", et peuvent être hébergés par la
+communauté à RubyGems.org. Chaque gem contient son code source et quelques
+métadatas, includant des choses comme la version, les dépendances,
+l(es) auteur(s) et la/les licence(s).
+
+## Bundler
+
+[Bundler](http://bundler.io/) est un outil de résolution de dépendances des gems. Il
+utilise le Gemfile d'un projet pour en trouver les dépendances, et récupère
+ensuite les dépendances de ces dépendances récursivement. Il déroule cet
+algorithme jusqu'à ce que toutes les dépendances soient résolues et
+téléchargées, ou s'arrête si un conflit est trouvé.
+
+Bundler lèvera une erreur s'il trouve des conflits de dépendances. Par exemple,
+si la gem A recquiert la version 3 ou plus de gem Z, mais que gem B recquiert
+seulement la version 2 de la même gem Z, Bundler vous notifiera ce conflit. Cela devient
+extrêmement utile, étant donné que beaucoup de gems font référence à d'autres
+gems (qui se réfèrent à d'autres gems et ainsi de suite), ce qui peut former un large graphe de
+dépendance à résoudre.
+
+# Les tests
+
+Tester fait partie intégrante de la culture Ruby. Ruby fournit son propre
+framework de tests unitaires appelé minitest (ou TestUnit pour Ruby
+version 1.8.x). Il existe beaucoup de librairies de tests avec des buts
+différents.
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Framework de tests intégré de Ruby version 1.8 style "Unit"
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Framework de tests intégré de Ruby version 1.9/2.0
+* [RSpec](http://rspec.info/) - Un framework de tests qui se focalise sur l'expressivité
+* [Cucumber](http://cukes.info/) - Un framework de tests BDD ([behaviour-driven development](https://fr.wikipedia.org/wiki/Behavior_driven_development)) qui parse les tests formatés de Gherkin.
+
+## Soyez gentil
+
+La communauté Ruby est fière d'être une communauté ouverte, riche et
+accueillante. Matz lui-même est extrêmement sociable, et la générosité des
+rubyistes est généralement remarquable.
diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
index 1564d2b6..6b487a07 100644
--- a/fr-fr/ruby-fr.html.markdown
+++ b/fr-fr/ruby-fr.html.markdown
@@ -7,9 +7,11 @@ contributors:
   - ["Luke Holder", "http://twitter.com/lukeholder"]
   - ["Tristan Hume", "http://thume.ca/"]
   - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+
 translators:
   - ["Geoffrey Roguelon", "https://github.com/GRoguelon"]
   - ["Nami-Doc", "https://github.com/Nami-Doc"]
+  - ["Sylvain Abélard", "http://github.com/abelards"]
 lang: fr-fr
 ---
 
@@ -22,19 +24,23 @@ Personne ne les utilise
 Vous devriez en faire de même
 =end
 
-# Tout d'abord : Tout est un objet.
+# Tout d'abord : tout est un objet.
 
 # Les nombres sont des objets
 
-3.class #=> Fixnum
+3.class #=> Fixnum # on voit que c'est une classe Ruby et non un "type spécial"
 
-3.to_s #=> "3"
+3.to_s #=> "3" # on peut appeler des méthodes sur ces objets, comme `to_s` (transforme en texte)
 
 # Les opérateurs de base
 1 + 1 #=> 2
 8 - 1 #=> 7
 10 * 2 #=> 20
-35 / 5 #=> 7
+22 / 7 #=> 3 # si les deux éléments sont entiers, c'est une division entière
+22.0 / 7 #=> 3.142857142857143
+22 / 7.0 #=> 3.142857142857143
+2**10 #=> 1024 # exposant
+1024 % 10 #=> 4 # modulo (reste de la division euclidienne)
 
 # Les opérateurs sont juste des raccourcis
 # pour appeler une méthode sur un objet
@@ -42,9 +48,9 @@ Vous devriez en faire de même
 10.* 5 #=> 50
 
 # Les valeurs spéciales sont des objets
-nil # Nul
-true # Vrai
-false # Faux
+nil # nul, vide ou indéfini
+true # vrai
+false # faux
 
 nil.class #=> NilClass
 true.class #=> TrueClass
@@ -60,8 +66,7 @@ false.class #=> FalseClass
 !true  #=> false
 !false #=> true
 
-# à part false lui-même, nil est la seule autre valeur 'false'
-
+# à part false lui-même, nil est la seule autre valeur "considérée comme fausse"
 !nil   #=> true
 !false #=> true
 !0     #=> false
@@ -73,7 +78,6 @@ false.class #=> FalseClass
 2 >= 2 #=> true
 
 # Les chaînes de caractères sont des objets
-
 'Je suis une chaîne de caractères'.class #=> String
 "Je suis également une chaîne de caractères".class #=> String
 
@@ -84,6 +88,15 @@ placeholder = "utiliser l'interpolation de chaîne de caractères"
 # Affichez un message
 puts "J'affiche à l'écran!"
 
+# Il y a quelques autres raccourcis pour les chaînes de caractères
+rb = "Ruby"
+interpolation = "Bonjour Ruby" # s'écrit aussi %Q[Bonjour #{rb}] %Q{Bonjour #{rb}} avec l'interpolation
+literal = "Bonjour \#{rb}" # avec le backslash, le dièse est un "vrai dièse" (le slash ne s'affiche que pour le debug)
+literal == %q[Bonjour #{rb}] # le Q majuscule fait l'interpolation, le q minuscule ne la fait pas
+multi = %Q[Cette chaîne
+est sur plusieurs
+lignes] # => "Cette chaîne\nest sur plusieurs\nlignes" # le caractère \n signifie retour à la ligne
+
 # Variables
 x = 25 #=> 25
 x #=> 25
@@ -131,7 +144,7 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 [1, "hello", false] #=> [1, "hello", false]
 
 # Les tableaux peuvent être indexés
-# Du début
+# Trouver la valeur en donnant la position en partant du début (le premier élément est à l'index 0)
 array[0] #=> 1
 array[12] #=> nil
 
@@ -140,13 +153,13 @@ array[12] #=> nil
 array.[] 0 #=> 1
 array.[] 12 #=> nil
 
-# Depuis la fin
+# On peut compter en partant de la fin avec un index négatif (le dernier élément est à l'index -1)
 array[-1] #=> 5
 
-# Avec un index de début et de fin
-array[2, 4] #=> [3, 4, 5]
+# Avec un index de début et un nombre d'éléments [position, nombre]
+array[1, 3] #=> [2, 3, 4]
 
-# Ou avec un intervalle
+# Ou avec un intervalle [index de début .. index de fin]
 array[1..3] #=> [2, 3, 4]
 
 # Ajoutez un élément au tableau comme ceci
@@ -180,11 +193,11 @@ new_hash.keys #=> [:defcon, :action]
 # Structures de contrôle
 
 if true
-  "si instruction"
+  "si l'instruction est vraie"
 elsif false
-  "autrement si, facultatif"
+  "si l'instruction de départ n'était pas vraie, et que cette nouvelle condition est vraie (facultatif)"
 else
-  "autrement, également facultatif"
+  "tous les autres cas (il est également facultatif de faire une clause else)"
 end
 
 for compteur in 1..5
diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown
new file mode 100644
index 00000000..b3675f5b
--- /dev/null
+++ b/fr-fr/rust-fr.html.markdown
@@ -0,0 +1,318 @@
+---
+language: rust
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+    - ["Ryan Rembert", "http://jrrembert.github.io"]
+filename: learnrust-fr.rs
+lang: fr-fr
+---
+
+Rust est un langage de programmation développé par Mozilla Research. Rust combine le contrôle de bas niveau sur la performance avec la commodité et la sécurité garanties de haut niveau.
+
+Il atteint ces objectifs sans avoir besoin d'un ramasse-miettes ou environnement d'exécution, ce qui rend possible l'utilisation de bibliothèques Rust comme une substitution directe pour C.
+
+La première version de Rust, 0.1, est sortie en janvier 2012 et a tellement évolué rapidement que jusqu'à récemment, l'utilisation de versions stables était déconseillée - à la place ce était conseillé d'utiliser les nightly builds.
+
+Le 15 mai 2015, Rust 1.0 a été libéré avec une garantie complète de compatibilité ascendante. Améliorations aux temps de compilation et d'autres aspects du compilateur sont actuellement disponibles dans la nightly builds. Rust a adopté un modèle de train de livraison avec les versions régulières toutes les six semaines. Rust 1.1 beta a été mis à disposition au moment de la livraison de Rust 1.0.
+
+Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts fonctionnels qui se trouvent généralement dans les langues de niveau supérieur. Cela rend Rust non seulement rapide, mais aussi efficace et facile à coder.
+
+```rust
+// Ceci est un commentaire. Les commentaires de ligne ressemblent à ceci...
+// et continuent sur plusieurs lignes comme cela.
+
+/// Les commentaires de documentation ressemblent à ça et supportent la
+/// syntaxe Markdown.
+/// # Exemples
+///
+/// ```
+/// let cinq = 5
+/// ```
+
+///////////////
+// 1. Basics //
+///////////////
+
+// Les fonctions
+// `I32` est le type 32 bits entiers signés
+fn add2(x: i32, y: i32) -> i32 {
+    // Retour implicite (pas de point virgule)
+    x + y
+}
+
+// Fonction principale
+fn main() {
+    // Nombres //
+
+    // Liaison immutable
+    let x: i32 = 1;
+
+    // Suffixes entiers et flottants
+    let y: I32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Inférence de type
+    // La plupart du temps, le compilateur Rust peut déduire quel est le type 
+    // de variable, donc vous n'avez pas à écrire une annotation de type explicite.
+    // Tout au long de ce tutoriel, les types sont explicitement annotées dans
+    // de nombreux endroits, mais seulement à des fins de démonstration.
+    // L'inférence de type peut les générer pour vous la plupart du temps.
+    let implicit_x = 1;
+    let implicit_f = 1,3;
+
+    // Arithmétique
+    let somme = x + y + 13;
+
+    // Variable Mutable
+    let mut mutable = 1;
+    let mutable = 4;
+    let mutable += 2;
+
+    // Chaînes //
+
+    // Chaîne littérales
+    let x: &str = "Bonjour tout le monde !";
+
+    // Affichage
+    println!("{} {}", f, x); // 1.3 Bonjour tout le monde
+
+    // Une `Chaîne` - une chaîne de tas alloué
+    let s: String = "Bonjour tout le monde".to_string();
+
+    // Un morceau de chaîne - une vue immutable sur une autre chaîne.
+    // C'est essentiellement un pointeur immutable sur une chaîne - ça ne
+    // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
+    // le début et la fin de la chaîne.
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
+
+    // Vecteurs/tableau //
+
+    // Un tableau de taille fixe
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // Un tableau dynamique(vecteur)
+    let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
+    vecteur.push(5);
+
+    // Une tranche - une vue immutable sur un vecteur ou un tableau.
+    // Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
+    let tranche: &[i32] = &vecteur;
+
+    // Utiliser `{:?}` pour afficher quelque chose en mode debug
+    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuples //
+
+    // Un tuple est un ensemble de valeurs qui peuvent être de différents types.
+    let x:(i32, &str, f64) = (1, "bonjour", 3.4);
+
+    // Déstructurer `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 bonjour 3.4
+
+    // indexation
+    println!("{}", x.1); // Bonjour
+
+    //////////////
+    // 2. Types //
+    //////////////
+
+    // Struct
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origine: Point = Point { x: 0, y: 0 };
+
+    // Un struct avec des champs sans nom, appelé 'tuple struct'.
+    struct Point2(i32, i32);
+
+    let origine2 = Point2(0, 0);
+
+    // Basic C-like enum
+    enum Direction {
+        Àgauche,
+        Droite,
+        En_Haut,
+        Vers_Le_Bas,
+    }
+
+    let en_haut = Direction::En_Haut;
+
+    // Enum avec des champs
+    enum OptionnelI32 {
+        AnI32(I32),
+        Rien,
+    }
+
+    let deux: OptionnelI32 = OptionnelI32::AnI32(2);
+    let rien = OptionnelI32::Rien;
+
+    // Generics //
+
+    struct Foo<T> { bar: T }
+
+    // Ceci est défini dans la bibliothèque standard comme `Option`.
+    enum Optionnel<T> {
+        SomeVal(T),
+        NoVal,
+    }
+
+    // Méthodes //
+
+    impl<T> Foo<T> {
+        // Méthodes prennent un paramètre explicite `de self`.
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Traits (connu sous le nom des interfaces ou des classes de types dans
+    // d'autres langues).
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+    /////////////////////////
+    // 3. Motif correspondant //
+    /////////////////////////
+
+    let foo = OptionnelI32::AnI32(1);
+    match foo {
+        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
+        OptionnelI32::Rien     => println!("Il n'y a rien!"),
+    }
+
+    // Motif avancé correspondant
+    struct FooBar { x: i32, y: OptionnelI32 }
+    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
+            println!("Les chiffres sont nuls!"),
+        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
+            println!("Les chiffres sont les mêmes"),
+        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
+            println!("Différents numéros: {} {}", n, m)!,
+        FooBar { x: _, y: OptionnelI32 :: Rien} =>
+            println!("Le deuxième numéro est rien!"),
+    }
+
+    /////////////////////
+    // 4. Flux de contrôle //
+    /////////////////////
+
+    // `for` boucles / itération
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Ranges
+    for i in 0u32..10 {
+        print!("{}", i);
+    }
+    println!("");
+    // imprime `0 1 2 3 4 5 6 7 8 9`
+
+    // `if`
+    if 1 == 1 {
+        println!("Maths est travaille!");
+    } else {
+        println!("Oh non ...!");
+    }
+
+    // `if` comme expression
+    let valeur = if true {
+        "bien"
+    } else {
+        "mal"
+    };
+
+    // `while` boucle
+    while 1 == 1 {
+        println!("L'univers fonctionne normalement.");
+    }
+
+    // Boucle infinie
+    loop {
+        println!("Bonjour!");
+    }
+
+    /////////////////////////////////
+    // 5. Sécurité & pointeurs mémoire //
+    /////////////////////////////////
+
+    // Pointeur occasion - une seule chose peut "posséder" pointeur à un moment.
+    // Cela signifie que lorsque le `Box` laisse son champ d'application, il
+    // peut être automatiquement libérée en toute sécurité.
+    let mut mine: Box<i32> = Box::new(3);
+    *mine = 5; // déréférencer
+    // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
+    // `mine` est déplacé.
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // 7
+    // println!("{}", now_its_mine); // Cela ne compile pas parce
+    // que `now_its_mine` possède maintenant le pointeur
+
+    // Référence - un pointeur immutable qui fait référence à d'autres données.
+    // Quand une référence est prise à une valeur, nous disons que la valeur
+    // a été "emprunté".
+    // Même si une valeur est emprunté immutablement, il ne peut pas être
+    // muté ou déplacé.
+    // Un emprunt dure jusqu'à la fin de la portée, il a été créé.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
+    println!("{}", *ref_var);
+    // Var = 5; // Cela ne compile pas parce que `var` est emprunté.
+    // *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
+    // référence immutable.
+
+    // Référence Mutable
+    // Même si une valeur est empruntée de façon mutable, elle ne peut pas être
+    // accessible à tous.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    // '*' est utilisé pour pointer vers le var2 mutably emprunté.
+    *ref_var2 += 2;
+
+    println!("{}", * ref_var2); // 6, // var2 ne compilerait pas.
+    // ref_var2 est de type &mut i32 donc stocke la référence à i32,
+    // pas la valeur.
+    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
+}
+```
+
+## Autres lectures
+
+Il y a beaucoup plus à Rust -- ce est juste l'essentiel de Rust afin que vous puissiez comprendre
+les choses les plus importantes. Pour en savoir plus sur Rust, lire [La Programmation Rust
+Langue](http://doc.rust-lang.org/book/index.html) et etudier la
+[/r/rust](http://reddit.com/r/rust) subreddit. Les gens sur le canal de #rust sur
+irc.mozilla.org sont aussi toujours prêts à aider les nouveaux arrivants.
+
+Vous pouvez également essayer caractéristiques de Rust avec un compilateur en ligne sur le fonctionnaire
+[Rust parc](http://play.rust-lang.org) ou sur la principale
+[Site Rust](http://rust-lang.org).
diff --git a/fr-fr/tmux-fr.html.markdown b/fr-fr/tmux-fr.html.markdown
new file mode 100644
index 00000000..d353af3b
--- /dev/null
+++ b/fr-fr/tmux-fr.html.markdown
@@ -0,0 +1,261 @@
+---
+category: tool
+tool: tmux
+contributors:
+    - ["mdln", "https://github.com/mdln"]
+translators:
+    - ["Xuan-thi Nguyen", "https://github.com/mellenguyen"]
+filename: LearnTmux-fr.txt
+lang: fr-fr
+---
+
+
+[Tmux](http://tmux.sourceforge.net) est un multiplexeur de terminal: il permet
+de créer plusieurs terminaux, accédés et contrôlés depuis un seul écran. Tmux
+peut être détaché de l'écran tout en continuant de fonctionner en tâche de
+fond, puis rattaché de nouveau.
+
+
+```
+
+  tmux [command]     # Exécute une commande
+                     # 'tmux' sans commande créé une nouvelle session
+
+    new              # Créé une nouvelle session
+     -s "Session"    # Créé une session nommée "Session"
+     -n "Window"     # Créé une fenêtre nommée "Window"
+     -c "/dir"       # Démarre dans le dossier cible "/dir"
+
+    attach           # S'attache à la dernière session ou la session disponible
+     -t "#"          # S'attache à la session cible
+     -d              # Détache la session des autres instances
+
+    ls               # Liste les sessions ouvertes
+     -a              # Liste toutes les sessions ouvertes
+
+    lsw              # Liste les fenêtres de la session courante
+     -a              # Liste toutes les fenêtres
+     -s              # Liste toutes les fenêtres en session
+
+    lsp              # Liste les panels
+     -a              # Liste tous les panels
+     -s              # Liste tous les panels en session
+     -t              # Liste tous les panels dans la cible
+
+    kill-window      # Tue la fenêtre courante
+     -t "#"          # Tue la fenêtre cible
+     -a              # Tue toutes les fenêtres
+     -a -t "#"       # Tue toutes les fenêtres sauf la cible
+
+    kill-session     # Tue la session courante
+     -t "#"          # Tue la session cible
+     -a              # Tue toutes les sessions
+     -a -t "#"       # Tue toutes les sessions sauf la cible
+
+```
+
+
+### Raccourcis clavier
+
+Afin de contrôler une session tmux attachée, on utilise une combinaison de
+touches appelées 'Préfixe'. Elle doit être pressée afin d'utiliser les
+raccourcis.
+
+```
+--------------------------------------------------------------------------------
+  (C-b) = Ctrl + b  # Combinaison 'Préfixe' requise pour utiliser les raccourcis
+
+  (M-1) = Meta + 1 -ou- Alt + 1
+--------------------------------------------------------------------------------
+
+  ?                  # Liste tous les raccourcis
+  :                  # Entre dans l'invite de commande de tmux
+  r                  # Force la redéfinition du client attaché
+  c                  # Créé une nouvelle fenêtre
+
+  !                  # Sépare le panel courant de sa fenêtre
+  %                  # Sépare le panel courant en deux, gauche et droite
+  "                  # Sépare le panel courant en deux, haut et bas
+
+  n                  # Changer vers la fenêtre suivante
+  p                  # Changer vers la fenêtre précédente
+  {                  # Echange le panel courant avec le panel précédent
+  }                  # Echange le panel courant avec le panel suivant
+
+  s                  # Sélectionne une nouvelle session pour le client attaché
+                     # de manière interactive
+  w                  # Choisi la fenêtre courante de manière interactive
+  0 to 9             # Sélectionne la fenêtre de 0 à 9
+
+  d                  # Détache le client courant
+  D                  # Choisi un client à détacher
+
+  &                  # Tue la fenêtre courante
+  x                  # Tue le panel courant
+
+  Up, Down           # Change vers le panel au dessus, en dessous, à gauche
+  Left, Right        # ou à droite
+
+  M-1 to M-5         # Arrange les panels:
+                       # 1) égaliser sur l'horizontale
+                       # 2) égaliser sur la verticale
+                       # 3) panel principal en haut et le reste en bas
+                       #    de gauche à droite
+                       # 4) panel principal à gauche et le reste à droite
+                       #    de haut en bas
+                       # 5) "tiled" : égalise les panels
+                       #    sur la hauteur et la largeur
+
+  C-Up, C-Down       # Redimensionne le panel courant par pas de une cellule
+  C-Left, C-Right
+
+  M-Up, M-Down       # Redimensionne le panel courant par pas de cinq cellules
+  M-Left, M-Right
+
+```
+
+
+### Configuration de ~/.tmux.conf
+
+tmux.conf peut être utilisé pour fixer les options automatiquement au
+démarrage, comme .vimrc ou init.el.
+
+```
+# Exemple de tmux.conf
+# 2014.10
+
+
+### Général
+###########################################################################
+
+# Active UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Limite de l'historique
+set -g history-limit 2048
+
+# Indice de début du nombre de panels
+set -g base-index 1
+
+# Souris
+set-option -g mouse-select-pane on
+
+# Force le rechargement du fichier de configuration
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Raccourcis clavier
+###########################################################################
+
+# Annule C-b en tant que préfixe par défaut
+unbind C-b
+
+# Définit un nouveau préfixe par défaut
+set-option -g prefix `
+
+# Retourne à la fenêtre précédente quand le préfixe est pressé deux fois
+bind C-a last-window
+bind ` last-window
+
+# Permet d'échanger C-a et ` en utilisant F11/F12
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Préférences de raccourcis clavier
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Navigue entre les panels avec les raccourcis clavier de vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Navigation entre les fenêtres
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# Commandes simples de séparation des panels
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+# Active la session la plus imbriquée (en faisant de l'imbrication sous tmux)
+# pour envoyer des commandes
+bind a send-prefix
+
+
+### Thème
+###########################################################################
+
+# Palette de couleurs pour la barre de statuts
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Palette de couleurs pour les bordures des panels
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Palette de couleurs pour les messages
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Palette de couleurs pour les fenêtres
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notification
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Définir automatiquement des titres de fenêtres
+set-option -g set-titles on
+# Numéro de fenêtre, nom du programme, actif (ou non)
+set-option -g set-titles-string '#H:#S.#I.#P #W #T'
+
+# Réglages de la barre de statuts
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Présente des indicateurs de performance dans la barre de statuts
+# Recquiert https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+
+### Références
+
+[Tmux | Home](http://tmux.sourceforge.net)
+
+[Page du manuel Tmux](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Montrer le pourcentage CPU/MEM dans la barre de statuts](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
+
+[tmuxinator - Gère des sessions tmux complexes](https://github.com/tmuxinator/tmuxinator)
diff --git a/fr-fr/vim.html.markdown b/fr-fr/vim.html.markdown
new file mode 100644
index 00000000..54c00b26
--- /dev/null
+++ b/fr-fr/vim.html.markdown
@@ -0,0 +1,239 @@
+---
+category: tool
+tool: vim
+filename: LearnVim.txt
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Thibault", "https://github.com/napnac"]
+lang: fr-fr
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) est le clone le plus populaire de l'éditeur de texte vi sous Unix.
+Vim est un éditeur de texte omniprésent sur les systèmes de type Unix, et a pour
+objectif la rapidité ainsi que l'augmentation de la productivité. Il a de 
+nombreux raccourcis claviers pour une navigation et une édition plus rapide.
+
+## Navigation basique avec Vim
+
+```
+    vim <ficher>     # Ouvre <fichier> avec vim
+    :q               # Quitte vim
+    :w               # Sauvegarde le fichier actuel
+    :wq              # Sauvegarde le fichier actuel et quitte vim
+    :q!              # Quitte vim sans sauvegarder
+                     # ! *force* l'exécution de :q, ce qui par conséquent 
+                     # oblige vim à quitter sans sauvegarder
+    :x               # Sauvegarde le fichier et quitte vim (raccourcis de :wq)
+
+    u                # Annuler
+    CTRL+R           # Rétablir
+
+    h                # Déplace le curseur vers la gauche
+    j                # Déplace le curseur vers le bas
+    k                # Déplace le curseur vers le haut
+    l                # Déplace le curseur vers la droite
+
+    # Mouvements au sein d'une ligne
+
+    0                # Va au début de la ligne
+    $                # Va à la fin de la ligne
+    ^                # Va au premier caractère non blanc de la ligne
+
+    # Rechercher dans un texte
+
+    /mot             # Surligne toutes les occurrences du mot après le curseur
+    ?mot             # Surligne toutes les occurrences du mot avant le curseur
+    n                # Déplace le curseur sur la prochaine occurrence du mot recherché
+    N                # Déplace le curseur sur la précédente occurrence du mot recherché
+
+    :%s/abc/def/g    # Transforme les 'abc' en 'def' sur chaque ligne du texte
+    :s/abc/def/g     # Transforme les 'abc' en 'def' sur la ligne actuelle
+
+    # Se déplacer vers un caractère
+
+    f<caractère>     # Se déplace en avant jusqu'à <caractère>
+    t<caractère>     # Se déplace en avant juste avant <caractère>
+
+    # Par exemple
+    f<               # Se déplace en avant jusqu'à <
+    t<               # Se déplace en avant juste avant <
+    
+    # Se déplacer dans un mot
+
+    w                # Avance d'un mot
+    b                # Recule d'un mot
+    e                # Se déplace jusqu'à la fin du mot actuel
+
+    # D'autres raccourcis pour se déplacer
+
+    gg               # Va au début du fichier
+    G                # Va à la fin du fichier
+    :NB              # Va à la ligne numéro NB (où NB est un nombre)
+    H                # Se déplace jusqu'en haut de l'écran
+    M                # Se déplace jusqu'au milieu de l'écran
+    L                # Se déplace jusqu'en bas de l'écran
+```
+
+## Modes
+
+Vim est basé sur le concept de **modes**.
+
+Mode Commande  - pour se déplacer et exécuter des commandes (vim démarre dans ce mode)
+Mode Insertion - pour éditer le fichier
+Mode Visuel    - pour sélectionner du texte et réaliser des opérations dessus
+Mode Ex        - pour entrer des commandes avec ':'
+
+```
+    i                # Mode insertion, avant le curseur
+    a                # Mode insertion, après le curseur
+    v                # Mode visuel
+    :                # Mode ex
+    <esc>            # 'Echap' permet de revenir dans le mode commande
+
+    # Copier/Coller du texte
+
+    y                # Copie le texte sélectionné
+    yy               # Copie la ligne actuelle
+    d                # Supprime ce qui est sélectionné
+    dd               # Supprime la ligne actuelle
+    p                # Colle après le curseur
+    P                # Colle avant le curseur
+    x                # Supprime le caractère sous le curseur
+```
+
+## La "Grammaire" de Vim
+
+Vim peut être vu comme un ensemble de commande sous la forme
+'Verbe-Modificateur-Nom' :
+
+Verbe        - notre action
+Modificateur - la manière de faire l'action
+Nom          - l'objet désigné par l'action
+
+Quelques exemples importants de 'Verbes', 'Modificateurs', et de 'Noms' :
+
+```
+    # 'Verbes'
+ 
+    d                # Supprime
+    c                # Transforme
+    y                # Copie
+    v                # Sélectionne
+
+    # 'Modificateurs'
+
+    i                # A l'intérieur
+    a                # Autour
+    NB               # Nombre
+    f                # Cherche quelque chose et se déplace dessus
+    t                # Cherche quelque chose et se déplace juste avant
+    /                # Cherche une chaîne de caractères après le curseur
+    ?                # Cherche une chaîne de caractères avant le curseur
+
+    # 'Noms'
+
+    w                # Mot
+    s                # Phrase
+    p                # Paragraphe
+    b                # Bloc
+    
+    # Exemple de 'phrases' ou commandes
+
+    d2w              # Supprime 2 mots
+    cis              # Transforme l'intérieur de la phrase
+    yip              # Copie l'intérieur du paragraphe
+    ct<              # Transforme le texte du curseur jusqu'au caractère avant le <
+    d$               # Supprime jusqu'à la fin de la ligne
+```
+
+## Quelques raccourcis et astuces
+
+```
+    >                # Indente la sélection d'un bloc
+    <                # Dé-indente la sélection d'un bloc
+    :earlier 15m     # Retrouve le document comme il était il y a 15 minutes
+    :later 15m       # Inverse la commande précédente
+    ddp              # Echange la position de deux lignes consécutives (dd puis p)
+    .                # Répète la dernière action effectuée
+```
+
+## Macros
+
+Les macros sont des actions enregistrables.
+Quand on commence à enregistrer une macro, Vim enregistre **toutes** les actions
+et les commandes que vous utilisez, jusqu'à ce que vous arrêtiez d'enregistrer.
+Lorsque vous appelez une macro, elle applique exactement les mêmes actions et 
+commandes sur le texte sélectionné.
+
+```
+    qa               # Commence l'enregistrement de la macro 'a'
+    q                # Arrête l'enregistrement
+    @a               # Appelle la macro 'a'
+```
+
+### Configuration de ~/.vimrc
+
+Le fichier .vimrc est utilisé pour configurer Vim lors du démarrage.
+
+Voici un exemple de fichier ~/.vimrc :
+
+```
+" Exemple de ~/.vimrc
+" 2015.10 
+
+" Nécessaire à Vim pour être 'iMproved'
+set nocompatible
+
+" Détermine l'extension du fichier à partir du nom pour permettre une indentation
+" automatique intelligente, etc.
+filetype indent plugin on
+
+" Active la coloration syntaxique
+syntax on
+
+" Une meilleure complétion de la ligne de commande
+set wildmenu
+
+" Utilise une recherche insensible à la case sauf quand on utilise des majuscules
+set ignorecase
+set smartcase
+
+" Quand on commence une nouvelle ligne et qu'aucun type d'indentation n'est activé
+" on utilise la même indentation que sur la ligne précédente
+set autoindent
+
+" Affiche le numéro de la ligne sur la gauche de l'écran
+set number
+
+" Options d'indentation, à changer en fonction des préférences personnelles
+
+" Nombre d'espaces visuels par tabulation
+set tabstop=4
+
+" Nombre d'espaces par tabulation
+set softtabstop=4
+
+" Nombre d'espaces indentés avec les opérations d'indentations (>> et <<)
+set shiftwidth=4
+
+" Convertis les tabulations en espaces
+set expandtab
+
+" Active des tabulations et des espaces intelligents pour l'indentation et l'alignement
+set smarttab
+```
+
+### Références
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)