Merge pull request #1 from adambard/master

Merging from master.

12 files changed, 1252 insertions, 130 deletions

diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
new file mode 100644
index 00000000..75c48811
--- /dev/null
+++ b/fr-fr/awk-fr.html.markdown
@@ -0,0 +1,377 @@
+---
+category: tool
+tool: awk
+filename: learnawk-fr.awk
+contributors:
+     - ["Marshall Mason", "http://github.com/marshallmason"]
+translators:
+    - ["GannonTdW", "https://github.com/GannonTdW"]
+lang: fr-fr
+
+---
+
+AWK est un outil standard présent dans chaque système UNIX conforme aux normes POSIX.
+C’est un outil en ligne de commande qui ressemble au Perl et qui est excellent dans les tâches de traitement de fichiers texte.
+Vous pouvez l’appeler à partir d’un script shell, ou l’utiliser comme un langage de script autonome.
+
+Pourquoi utiliser AWK au lieu du langage Perl ?
+Principalement, car AWK fait partie d'UNIX et est donc présent par défaut sur une très grande partie des systèmes d'exploitation UNIX et Linux. 
+AWK est aussi plus facile à lire que le langage Perl ; et est l'outil idéal pour ce qui concerne le traitement de texte simple. Notamment le traitement de ceux qui necéssitent de lire des fichiers ligne par ligne ; chaque ligne comportant des champs séparés par des délimiteur.
+
+
+```awk
+#!/usr/bin/awk -f
+
+# Les commentaires commencent par un #
+
+
+# les programmes AWK consistent en une collection de règles et d'actions
+règle1 { action; }
+règle2 { action; }
+
+# AWK lit et analyse automatiquement chaque ligne de chaque fichier fourni.
+# Chaque ligne est divisée par un délimiteur FS qui est par défaut l'espace (plusieurs espaces ou une tabulation comptent pour un espace). Ce délimiteur peut être changer grâce à l'option -F ou être renseigné au début d'un bloc (exemple: FS = " ").
+
+# BEGIN est une règle spécifique exécutée au début du programme. C'est à cet endroit que vous mettrez tout le code à exécuter avant de traiter les fichiers texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le point d’entrée principal du script.
+# A l'opposé de BEGIN, il existe la règle END. Cette règle est présente après chaque fin de fichier (EOF : End Of File).
+
+BEGIN {
+
+    # Les variables sont globales. Pas besoin de les déclarer.
+    count = 0;
+
+    # les opérateurs sont identiques au langage C et aux langages similaires (exemple: C#, C++)
+    a = count + 1; # addition
+    b = count - 1; # soustraction
+    c = count * 1; # multiplication
+    d = count / 1; # division entière
+    e = count % 1; # modulo, reste de la division entière
+    f = count ^ 1; # exponentiel
+
+    a += 1;
+    b -= 1;
+    c *= 1;
+    d /= 1;
+    e %= 1;
+    f ^= 1;
+
+    # Incrémenter et décrémenter par un
+    a++;
+    b--;
+
+    # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui est retournée
+    ++a;
+    --b;
+
+    # Instruction de contrôle
+    if (conteur == 0)
+        print "Nombre de départ 0";
+    else
+        print "Hein?";
+
+    # Vous pouvez aussi utiliser l'opérateur ternaire
+    print (compteur == 0) ? "Nombre de départ 0" : "Hein?";
+
+    # Les blocs sont composés d'une multitude de lignes entre accolades
+    while (a < 10) {
+        print "La concaténation de chaînes de caractères" " se fait avec des séries de chaînes "    " séparées par des espaces";
+        print a;
+
+        a++;
+    }
+
+    for (i = 0; i < 10; i++)
+        print "le bon vieux for pour les boucles";
+
+    # Les opérateurs de comparaison sont standard
+    # a < b   # plus petit que
+    # a <= b  # plus petit ou égale à
+    # a != b  # non égale
+    # a == b  # égale
+    # a > b   # Plus grand que
+    # a >= b  # Plus grand ou égale à
+
+    # Les opérateurs logiques sont
+    # a && b  # ET
+    # a || b  # OU
+
+    # En plus, il y a les expressions régulières
+    if ("foo" ~ "^fo+$")
+        print "Fooey!";
+    if ("boo" !~ "^fo+$")
+        print "Boo!";
+
+    # Les Tableaux
+    arr[0] = "foo";
+    arr[1] = "bar";
+
+    # Vous pouvez aussi initialiser un tableau avec la fonction split()
+
+    n = split("foo:bar:baz", arr, ":");
+
+    # Il y a aussi les tableaux associatifs
+    assoc["foo"] = "bar";
+    assoc["bar"] = "baz";
+
+    # et les tableaux multi-dimentions, avec certaines limitations que l'on ne mentionnera pas ici
+    multidim[0,0] = "foo";
+    multidim[0,1] = "bar";
+    multidim[1,0] = "baz";
+    multidim[1,1] = "boo";
+
+    # Vous pouvez tester l'appartenance à un tableau
+    if ("foo" in assoc)
+        print "Fooey!";
+
+    # Vous pouvez aussi utilisez l'opérateur 'in' pour parcourir les clés d'un tableau
+    for (key in assoc)
+        print assoc[key];
+
+    # La ligne de commande est dans un tableau spécifique appelé ARGV
+    for (argnum in ARGV)
+        print ARGV[argnum];
+
+    # Vous pouvez supprimer des éléments d'un tableau
+    # C'est utile pour empêcher AWK de supposer que certains arguments soient des fichiers à traiter.
+    delete ARGV[1];
+
+    # Le nombre d'arguments de la ligne de commande est dans une variable appellée ARGC
+    print ARGC;
+
+    # AWK inclue trois catégories de fonction.
+    # On les examinera plus tard
+
+    return_value = arithmetic_functions(a, b, c);
+    string_functions();
+    io_functions();
+}
+
+# Voici comment définir une fonction
+function arithmetic_functions(a, b, c,     d) {
+
+    # La partie la plus ennuieuse de AWK est probablement l’absence de variables locales.
+    # Tout est global. Pour les scripts courts, c'est très utile, mais pour les scripts plus longs,
+    # cela peut poser problème.
+
+    # Il y a cepandant une solution de contournement (enfin ... une bidouille).
+    # Les arguments d'une fonction sont locaux à cette fonction.
+    # Et AWK vous permet de définir plus d'arguments à la fonction que nécessaire.
+    # Il suffit donc de mettre une variable locale dans la déclaration de fonction,
+    # comme ci-dessus. La convention veut que vous mettiez quelques espaces supplémentaires
+    # pour faire la distinction entre les paramètres réels et les variables locales.
+    # Dans cet exemple, a, b et c sont des paramètres réels,
+    # alors que d est simplement une variable locale.
+
+    # Maintenant, les fonctions arithmétiques
+
+    # La plupart des implémentations de AWK ont des fonctions trigonométriques standards
+    localvar = sin(a);
+    localvar = cos(a);
+    localvar = atan2(b, a); # arc tangente de b / a
+
+    # Les exponentiels et logarithmes décimaux sont aussi là
+    localvar = exp(a);
+    localvar = log(a);
+
+    # Les racines carrées
+    localvar = sqrt(a);
+
+    # Tronquer un nombre décimal en nombre entier
+    localvar = int(5.34); # localvar => 5
+
+    # Les nombres aléatoires
+    srand(); 
+    # L'argument de la fonction srand() est la valeur de départ pour générer
+    # les nombres aléatoires . Par défaut, il utilise l'heure du système
+    
+    localvar = rand(); # Nombre aléatoire entre 0 et 1.
+
+    # Maintenant on retourne la valeur
+    return localvar;
+}
+
+function string_functions(    localvar, arr) {
+
+    # AWK a plusieurs fonctions pour le traitement des chaînes de caractères,
+    # dont beaucoup reposent sur des expressions régulières.
+
+    # Chercher et remplacer, la première occurence (sub) ou toutes les occurences (gsub)
+    # Les deux renvoient le nombre de correspondances remplacées
+    localvar = "fooooobar";
+    sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
+    gsub("e+", ".", localvar); # localvar => "m..t m. at th. bar"
+
+    # Rechercher une chaîne de caractères qui correspond à une expression régulière
+    # index() fait la même chose, mais n'autorise pas les expressions régulières
+    match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère
+
+    # Séparer par un délimiteur
+    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
+
+    # Autre astuces utiles
+    sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
+    substr("foobar", 2, 3); # => "oob"
+    substr("foobar", 4); # => "bar"
+    length("foo"); # => 3
+    tolower("FOO"); # => "foo"
+    toupper("foo"); # => "FOO"
+}
+
+function io_functions(    localvar) {
+
+    # Vous avez déjà vu print
+    print "Hello world";
+
+    # Mais il y a aussi printf
+    printf("%s %d %d %d\n", "Testing", 1, 2, 3);
+
+    # AWK n'a pas de descripteur de fichier en soi. Il ouvrira automatiquement
+    # un descripteur de fichier lorsque vous utilisez quelque chose qui en a besoin.
+    # La chaîne de caractères que vous avez utilisée pour cela peut être traitée
+    # comme un descripteur de fichier à des fins d'entrée / sortie.
+
+    outfile = "/tmp/foobar.txt";
+
+    print "foobar" > outfile;
+
+    # Maintenant, la chaîne de caractères "outfile" est un descripteur de fichier.
+    # Vous pouvez le fermer
+    close(outfile);
+
+    # Voici comment exécuter quelque chose dans le shell
+    system("echo foobar"); # => affiche foobar
+
+    # Lire quelque chose depuis l'entrée standard et la stocker dans une variable locale
+    getline localvar;
+
+    # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une chaine de caractère
+    # que vous fermerez proprement)
+    "echo foobar" | getline localvar # localvar => "foobar"
+    close("echo foobar")
+
+    # Lire une ligne d'un fichier et la stocker dans une variable locale
+    infile = "/tmp/foobar.txt";
+    getline localvar < infile;
+    close(infile);
+}
+
+# Comme dit au début, AWK consiste en une collection de règles et d'actions.
+# Vous connaissez déjà les règles BEGIN et END. Les autres règles ne sont utilisées que si vous traitez 
+# des lignes à partir de fichiers ou l'entrée standard (stdin).
+# Quand vous passez des arguments à AWK, ils sont considérés comme des noms de fichiers à traiter.
+# AWK les traitera tous dans l'ordre. Voyez les comme dans à une boucle implicite,
+# parcourant les lignes de ces fichiers.
+# Ces règles et ces actions ressemblent à des instructions switch dans la boucle.
+
+/^fo+bar$/ {
+
+    # Cette action sera exécutée pour chaque ligne qui correspond à l'expression régulière,
+    # /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond pas.
+    # Imprimons simplement la ligne:
+
+    print;
+
+    # Pas d'argument ! C'est parce que print a un défaut : $0.
+    # $0 est le nom de la ligne en cours de traitement. Il est créé automatiquement.
+
+    # Vous devinez probablement qu'il existe d'autres variables $.
+    # Chaque ligne est divisée implicitement avant que chaque action soit exécutée, comme
+    # le fait le shell. Et, comme le shell, chaque champ est accessible avec un signe dollar
+
+     # Ceci affichera les deuxième et quatrième champs de la ligne.
+    print $2, $4;
+
+    # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous aider
+    # à inspecter et traiter chaque ligne. La plus importante est NF
+
+    # Affiche le nombre de champs de la ligne
+    print NF;
+
+    # Afficher le dernier champ de la ligne
+    print $NF;
+}
+
+# Chaque règle est en réalité un test conditionel. 
+
+a > 0 {
+    # Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif
+}
+
+# Les expressions régulières sont également des tests conditionels.
+#Si le test de l'expression régulières n'est pas vrais alors le bloc n'est pas executé
+$0 /^fobar/ { 
+   print "la ligne commance par fobar"  
+}
+
+# Dans le cas où vous voulez tester votre chaine de caractères sur la ligne en cours de traitement
+# $0 est optionnelle.
+
+/^[a-zA-Z0-9]$/ {
+    print "La ligne courante ne contient que des caractères alphanumériques.";
+}
+
+
+# AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en fonction de règles établies
+# Cela est si courant sous UNIX qu'AWK est un langage de script.
+
+# Ce qui suit est un exemple rapide d'un petit script, pour lequel AWK est parfait.
+# Le script lit un nom à partir de l'entrée standard, puis affiche l'âge moyen de toutes les
+# personnes portant ce prénom.
+# Supposons que vous fournissiez comme argument le nom d'un fichier comportant ces données:
+#
+# Bob Jones 32
+# Jane Doe 22
+# Steve Stevens 83
+# Bob Smith 29
+# Bob Barker 72
+#
+# Le script est le suivant :
+
+BEGIN {
+
+    # Premièrement, on demande à l'utilisateur le prénom voulu
+    print "Pour quel prénom vouldriez vous savoir l'age moyen ?";
+
+    # On récupère la ligne à partir de l'entrée standard, pas de la ligne de commande
+    getline name < "/dev/stdin";
+}
+
+# Maintenant, pour chaque ligne dont le premier champ est le prénom donné
+$1 == name {
+
+    # Ici, nous avons accès à un certain nombre de variables utiles déjà préchargées :
+    # $0 est la ligne entière
+    # $3 est le troisième champ. Ici il correspond à l'age qui nous intéresse
+    # NF est le nombre de champs et vaut 3
+    # NR est le nombre d'enregistrements (lignes) vus jusqu'à présent
+    # FILENAME est le nom du fichier en cours de traitement
+    # FS est séparateur de champs, ici c'est " " (un espace)
+    # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de man.
+    # Pour cela exécutez "man awk" dans votre terminal
+
+    # Garder une trace du total accumulé et du nombre de lignes correspondant.
+    sum += $3;
+    nlines++;
+}
+
+# Un autre motif spécial est END. Il fonctionnera après le traitement de tous
+# les fichiers texte. Contrairement à BEGIN, il ne fonctionne que si vous lui
+# donnez une entrée à traiter. Il sera exécuté une fois que tous les fichiers
+# auront été lus et traités conformément aux règles et aux actions que vous
+# avez fournies. Le but est généralement de produire un rapport final
+# ou de faire quelque chose avec l'ensemble des données que vous avez
+# accumulées au cours du script.
+
+
+END {
+    if (nlines)
+        print "L'age moyen pour le prénom " name " est " sum / nlines;
+}
+
+```
+Pour plus d'informations :
+
+* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
+* [Awk man page](https://linux.die.net/man/1/awk)
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk est dans la majorité des systèmes Linux.
+* [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown
index acbaed58..863162f7 100644
--- a/fr-fr/c++-fr.html.markdown
+++ b/fr-fr/c++-fr.html.markdown
@@ -910,7 +910,6 @@ 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>
+* Une référence à jour du langage est disponible à [CPP Reference](http://cppreference.com/w/cpp).
+* Des ressources supplémentaires sont disponibles à [CPlusPlus](http://cplusplus.com).
+* Un tutoriel couvrant les bases du langage et la configuration d'un environnement de codage est disponible à l'adresse [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
index 24e8c95f..ea547dae 100644
--- a/fr-fr/dynamic-programming-fr.html.markdown
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -8,7 +8,6 @@ translators:
 lang: fr-fr
 ---
 
-
 # Programmation dynamique
 
 ## Introduction
@@ -17,9 +16,9 @@ La programmation dynamique est une technique très efficace pour résoudre une c
 
 ## 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.
+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.
+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
 
@@ -27,7 +26,7 @@ Le problème de la plus grande sous-chaîne croissante est de trouver la plus gr
 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. 
+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é.  
 
@@ -43,12 +42,9 @@ Le même concept peut être appliqué pour trouver le chemin le plus long dans u
 
 ### 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
+- [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
 
diff --git a/fr-fr/elixir-fr.html.markdown b/fr-fr/elixir-fr.html.markdown
new file mode 100644
index 00000000..90cdad7c
--- /dev/null
+++ b/fr-fr/elixir-fr.html.markdown
@@ -0,0 +1,479 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
+    - ["Ev Bogdanov", "https://github.com/evbogdanov"]
+translator:
+    - ["Timothé Pardieu", "https://github.com/timprd"]
+filename: learnelixir-fr.ex
+lang: fr-fr
+---
+Elixir est un langage de programmation fonctionnel moderne reposant sur la machine virtuelle BEAM, qui héberge aussi Erlang.
+Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréable et apporte de nouvelles fonctionnalités. 
+
+
+```elixir
+
+# Un commentaire simple sur une seule ligne commence par un dièse.
+
+# Il n'y a pas de commentaire multi-ligne,
+# Mais il est possible de les empiler comme ici.
+
+# La commande `iex` permet de lancer le shell Elixir.
+# La commande `elixirc` permet de compiler vos modules.
+
+# Les deux devraient être dans votre path si vous avez installé Elixir correctement.
+
+## ---------------------------
+## -- Types basiques
+## ---------------------------
+
+# Il y a les nombres
+3    # Integer 
+0x1F # Integer
+3.0  # Float
+
+# Les atomes, des littéraux, qui sont des constantes avec comme valeur leur nom. 
+# Ils commencent par `:`.
+
+:hello # atom
+
+# Il existe également des n-uplets dont les valeurs sont stockés de manière contiguë 
+# en mémoire.
+
+{1,2,3} # tuple
+
+# Il est possible d'accéder à un element d'un tuple avec la fonction 
+# `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Les listes sont implémentées sous forme de listes chainées.
+[1,2,3] # list
+
+# La tête et le reste d'une liste peuvent être récupérés comme cela :
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# En Elixir, comme en Erlang, le `=` dénote un 'pattern matching' 
+# (Filtrage par motif) et non une affectation.
+# Cela signifie que la partie de gauche (pattern) est comparé (match) à 
+# la partie de droite. 
+
+
+# Une erreur sera lancée si aucun model (match) est trouvé.
+# Dans cet exemple les tuples ont des tailles différentes
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Il y a aussi les binaires
+<<1,2,3>> # binary
+
+# Chaine de caractères et liste de caractères
+"hello" # string
+'hello' # char list
+
+# Chaine de caractères sur plusieurs lignes
+"""
+Je suis une chaine de caractères
+sur plusieurs lignes.
+"""
+#=> "Je suis une chaine de caractères\nsur plusieurs lignes.\n"
+
+# Les chaines de caractères sont encodées en UTF-8 :
+"héllò" #=> "héllò"
+
+# Les chaines de caractères sont des binaires tandis que
+# les listes de caractères sont des listes.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` en Elixir retourne le code ASCII (Integer) de la lettre `a`
+?a #=> 97
+
+# Pour concaténer des listes il faut utiliser `++`, et `<>` pour les
+# binaires
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+# Les intervalles sont représentés de cette sorte `début..fin`
+# (tout deux inclusifs)
+1..10 #=> 1..10
+bas..haut = 1..10 # Possibilité d'utiliser le pattern matching sur les intervalles aussi.
+[bas, haut] #=> [1, 10]
+
+# Les Maps (Tableau associatif) sont des paires clée - valeur
+genders = %{"david" => "male", "gillian" => "female"}
+genders["david"] #=> "male"
+
+# Les maps avec des atomes peuvent être utilisés comme cela
+genders = %{david: "male", gillian: "female"}
+genders.gillian #=> "female"
+
+## ---------------------------
+## -- Operateurs
+## ---------------------------
+
+# Mathématiques
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# En Elixir l'opérateur `/` retourne toujours un Float (virgule flottante).
+
+# Pour faire une division avec entier il faut utiliser `div`
+div(10, 2) #=> 5
+
+# Pour obtenir le reste de la division il faut utiliser `rem`
+rem(10, 3) #=> 1
+
+# Il y a aussi les opérateurs booléen: `or`, `and` et `not`.
+# Ces opérateurs attendent un booléen en premier argument.
+true and true #=> true
+false or true #=> true
+# 1 and true
+#=> ** (BadBooleanError) expected a booléens on left-side of "and", got: 1
+
+# Elixir fournit aussi `||`, `&&` et `!` qui acceptent des arguments de
+# tout type.
+# Chaque valeur sauf `false` et `nil` seront évalués à vrai (true).
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Pour les comparaisons il y a : `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` et `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` et `!==` sont plus stricts en comparant les Integers (entiers) 
+# et les Floats (nombres à virgules) :
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# On peut aussi comparer deux types de données différents :
+1 < :hello #=> true
+
+# L'ordre est défini de la sorte :
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+# Pour citer Joe Armstrong : "The actual order is not important,
+# but that a total ordering is well defined is important."
+
+## ---------------------------
+## -- Structure de contrôle
+## ---------------------------
+
+# Condition avec `if` (si)
+if false do
+  "Cela ne sera pas vu"
+else
+  "Cela le sera"
+end
+
+# Condition avec `unless` (sauf).
+# Il correspond à la négation d'un `if` (si) 
+unless true do
+  "Cela ne sera pas vu"
+else
+  "Cela le sera"
+end
+
+# Beaucoup de structures en Elixir se basent sur le pattern matching.
+# `case` permet de comparer une valeur à plusieurs modèles:
+case {:one, :two} do
+  {:four, :five} ->
+    "Ne match pas"
+  {:one, x} ->
+    "Match et lie `x` à `:two` dans ce cas"
+  _ ->
+    "Match toutes les valeurs"
+end
+
+# Il est commun de lier la valeur à `_` si on ne l'utilise pas.
+# Par exemple, si seulement la tête d'une liste nous intéresse:
+[head | _] = [1,2,3]
+head #=> 1
+
+# Pour plus de lisibilité, ce procédé est utilisé:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` permet de vérifier plusieurs conditions à la fois.
+# Il est conseillé d'utiliser `cond` plutôt que des `if` imbriqués.
+cond do
+  1 + 1 == 3 ->
+    "Je ne serai pas vu"
+  2 * 5 == 12 ->
+    "Moi non plus"
+  1 + 2 == 3 ->
+    "Mais moi oui"
+end
+
+# Il est commun d'attribuer la dernière condition à true (vrai), qui
+# matchera toujours.
+cond do
+  1 + 1 == 3 ->
+    "Je ne serai pas vu"
+  2 * 5 == 12 ->
+    "Moi non plus"
+  true ->
+    "Mais moi oui (représente un else)" 
+end
+
+# `try/catch` est utilisé pour attraper les valeurs rejetées. 
+# Il supporte aussi un 
+# `after` qui est appelé autant si une valeur est jetée ou non.
+try do
+  throw(:hello)
+catch
+  message -> "Message : #{message}."
+after
+  IO.puts("Je suis la clause after (après).")
+end
+#=> Je suis la clause after (après).
+# "Message : :hello"
+
+## ---------------------------
+## -- Modules et Fonctions
+## ---------------------------
+
+# Fonctions anonymes (notez le point).
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Les fonctions anonymes acceptent aussi de nombreuses clauses et guards (gardes).
+# Les guards permettent d'affiner le pattern matching,
+# ils sont indiqués par le mot-clef `when` :
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir propose aussi de nombreuses fonctions internes.
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Il est possible de grouper plusieurs fonctions dans un module.
+# Dans un module, les fonctions sont définies par `def`
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# Pour compiler notre module `Math`,
+# il faut le sauvegarder en tant que `math.ex` et utiliser `elixirc`.
+# Executez ainsi `elixirc math.ex` dans le terminal.
+
+# Au sein d'un module, nous pouvons définir les fonctions avec `def`
+# et `defp` pour les fonctions privées.
+# Une fonction définie par `def` est disponible dans les autres
+# modules. Une fonction privée est disponible localement seulement.
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# La déclaration de fonction supporte également les guards (gardes) 
+# et les clauses. 
+# Quand une fonction avec plusieurs clauses est appelée,
+# la première fonction dont la clause est satisfaite par les arguments sera appelée.
+# Exemple: le code `area({:circle, 3})` appelle la deuxième fonction definie plus bas,
+# et non la première car ses arguments correspondent à la signature de cette dernière:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# En raison de l'immutabilité, la récursivité est une grande partie
+# d'Elixir
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Les modules Elixir supportent des attributs internes,
+# ceux-ci peuvent aussi être personnalisés.
+defmodule MyMod do
+  @moduledoc """
+  This is a built-in attribute on a example module.
+  """
+
+  @my_data 100 # Attribut personnel.
+  IO.inspect(@my_data) #=> 100
+end
+
+# L'opérateur pipe (|>) permet de passer la sortie d'une expression
+# en premier paramètre d'une fonction. 
+
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
+## ---------------------------
+## -- Structs et Exceptions
+## ---------------------------
+
+# Les Structs sont des extensions des Maps.
+# Apportant en plus les valeurs par defaut, le polymorphisme et 
+# la vérification à la compilation dans Elixir.
+defmodule Person do
+  defstruct name: nil, age: 0, height: 0
+end
+
+jean_info = %Person{ name: "Jean", age: 30, height: 180 }
+#=> %Person{age: 30, height: 180, name: "Jean"}
+
+# Access the value of name
+jean_info.name #=> "Jean"
+
+# Update the value of age
+older_jean_info = %{ jean_info | age: 31 }
+#=> %Person{age: 31, height: 180, name: "Jean"}
+
+# Le bloc `try` avec le mot-clef `rescue` est utilisé pour gérer les exceptions
+try do
+  raise "some error"
+rescue
+  RuntimeError -> "rescued a runtime error"
+  _error -> "this will rescue any error"
+end
+#=> "rescued a runtime error"
+
+# Chaque exception possède un message
+try do
+  raise "some error"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "some error"
+
+## ---------------------------
+## -- Concurrence
+## ---------------------------
+
+# Elixir se repose sur le modèle d'acteur pour gérer la concurrence.
+# Pour écrire un programme concurrent en Elixir il faut trois 
+# primitives: spawning processes (création), sending messages (envoi) 
+# et receiving messages (réception).
+
+# Pour débuter un nouveau processus, il faut utiliser 
+# la fonction `spawn` qui prend en argument une fonction.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` retourn un pid (identifiant de processus), il est possible 
+# d'utiliser ce pid pour envoyer un message au processus.
+# Pour faire parvenir le message il faut utiliser l'opérateur `send`.
+# Pour que cela soit utile il faut être capable de recevoir les 
+# messages.
+# Cela est possible grâce au mechanisme de `receive`:
+
+# Le bloc `receive do` est utilisé pour écouter les messages et les traiter
+# au moment de la réception. Un bloc `receive do` pourra traiter un seul
+# message reçu.
+# Pour traiter plusieurs messages, une fonction avec un bloc `receive do` 
+# doit s'appeler elle-même récursivement.
+
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Ceci compile le module et créer un processus qui évalue dans le terminal `area_loop`
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+# Alternativement
+pid = spawn(Geometry, :area_loop, [])
+
+# On envoi un message au `pid` qui correspond à la régle de réception.
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# Le shell est aussi un processus, il est possible d'utiliser `self`
+# pour obtenir le pid du processus courant.
+self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agents
+## ---------------------------
+
+# Un agent est un processus qui garde les traces des valeurs modifiées.
+
+# Pour créer un agent on utilise `Agent.start_link` avec une fonction.
+# L'état initial de l'agent sera ce que la fonction retourne
+{ok, my_agent} = Agent.start_link(fn -> ["red", "green"] end)
+
+# `Agent.get` prend un nom d'agent et une fonction (`fn`).
+# Qu'importe ce que cette `fn` retourne, l'état sera ce qui est retourné.
+Agent.get(my_agent, fn colors -> colors end) #=> ["red", "green"]
+
+# Modification de l'état de l'agent
+Agent.update(my_agent, fn colors -> ["blue" | colors] end)
+```
+
+## Références
+
+* [Guide de debut](http://elixir-lang.org/getting-started/introduction.html) depuis le site [Elixir](http://elixir-lang.org)
+* [Documentation Elixir ](https://elixir-lang.org/docs.html)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) de Joe Armstrong
diff --git a/fr-fr/erlang-fr.html.markdown b/fr-fr/erlang-fr.html.markdown
index 55453c56..1073d6ad 100644
--- a/fr-fr/erlang-fr.html.markdown
+++ b/fr-fr/erlang-fr.html.markdown
@@ -28,7 +28,7 @@ lang: fr-fr
 %% 1. Variables et filtrage par motif
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-(L'équivalent anglais de *filtrage par motif* est *pattern patching*.)
+(L'équivalent anglais de *filtrage par motif* est *pattern matching*.)
 
 Nb = 42.  % Chaque nom de variable doit commencer par une lettre majuscule.
 
@@ -64,7 +64,7 @@ Point = {point, 10, 45}.
 {point, X, Y} = Point.  % X = 10, Y = 45
 
 % On peut utiliser `_` comme caractère joker pour les variables qui ne nous
-% intéressent pas. Le symbol `_` est appelé variable muette. Contrairement
+% intéressent pas. Le symbole `_` est appelé variable muette. Contrairement
 % aux variables normales, de multiples apparitions de `_` dans un même motif
 % ne lient pas nécessairement à la même valeur.
 Personne = {personne, {nom, {prenom, joe}, {famille, armstrong}},
diff --git a/fr-fr/java-fr.html.markdown b/fr-fr/java-fr.html.markdown
index d0f91611..d6c68343 100644
--- a/fr-fr/java-fr.html.markdown
+++ b/fr-fr/java-fr.html.markdown
@@ -11,7 +11,7 @@ contributors:
     - ["Michael Dähnert", "https://github.com/JaXt0r"]
     - ["Rob Rose", "https://github.com/RobRoseKnows"]
     - ["Sean Nam", "https://github.com/seannam"]
-filename: JavaFr.java
+filename: java-fr.java
 translators:
     - ['Mathieu Gemard', 'https://github.com/mgemard']
 lang: fr-fr
diff --git a/fr-fr/jquery-fr.html.markdown b/fr-fr/jquery-fr.html.markdown
index 1842e02b..1a5baf71 100644
--- a/fr-fr/jquery-fr.html.markdown
+++ b/fr-fr/jquery-fr.html.markdown
@@ -13,6 +13,7 @@ jQuery est une bibliothèque JavaScript dont le but est de permettre de "faire p
 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
 
 
@@ -138,5 +139,5 @@ $('p').each(function() {
 });
 
 
-``
+```
 
diff --git a/fr-fr/lambda-calculus-fr.html.markdown b/fr-fr/lambda-calculus-fr.html.markdown
new file mode 100644
index 00000000..c91f21d6
--- /dev/null
+++ b/fr-fr/lambda-calculus-fr.html.markdown
@@ -0,0 +1,106 @@
+---
+category: Algorithms & Data Structures
+name: Lambda Calculus
+contributors:
+    - ["Max Sun", "http://github.com/maxsun"]
+translators:
+    - ["Yvan Sraka", "https://github.com/yvan-sraka"]
+lang: fr-fr
+---
+
+# Lambda-calcul
+
+Le Lambda-calcul (λ-calcul), créé à l'origine par [Alonzo Church](https://en.wikipedia.org/wiki/Alonzo_Church), est le plus petit langage de programmation au monde. En dépit de ne pas avoir de nombres, de chaînes, de booléens, ou de tout type de données sans fonction, le lambda calcul peut être utilisé pour représenter n'importe quelle machine de Turing!
+
+Le Lambda-calcul est composé de 3 éléments : **variables**, **fonctions** et **applications**.
+
+
+| Nom         | Syntaxe                            | Exemple   | Explication                                       |
+|-------------|------------------------------------|-----------|---------------------------------------------------|
+| Variable    | `<nom>`                            | `x`       | une variable nommée "x"                           |
+| Fonction    | `λ<paramètres>.<corps>`            | `λx.x`    | une fonction avec le paramètre "x" et le corps "x"|
+| Application | `<fonction><variable ou function>` | `(λx.x)a` | appel de la fonction "λx.x" avec l'argument "a"   |
+
+La fonction la plus fondamentale est la fonction identité: `λx.x` qui est équivalente à `f(x) = x`. Le premier "x" est l'argument de la fonction, et le second est le corps de la fonction.
+
+## Variables libres et liées :
+
+- Dans la fonction `λx.x`, "x" s'appelle une variable liée car elle est à la fois dans le corps de la fonction et l'un des paramètres.
+- Dans `λx.y`, "y" est appelé une variable libre car elle n'a pas été déclarée plus tôt.
+
+## Évaluation :
+
+L'évaluation est réalisée par [β-Réduction](https://en.wikipedia.org/wiki/Lambda_calculus#Beta_reduction), qui est essentiellement une substitution lexicale.
+
+Lors de l'évaluation de l'expression `(λx.x)a`, nous remplaçons toutes les occurrences de "x" dans le corps de la fonction par "a".
+
+- `(λx.x)a` vaut après évaluation: `a`
+- `(λx.y)a` vaut après évaluation: `y`
+
+Vous pouvez même créer des fonctions d'ordre supérieur:
+
+- `(λx.(λy.x))a` vaut après évaluation: `λy.a`
+
+Bien que le lambda-calcul ne prenne traditionnellement en charge que les fonctions à un seul paramètre, nous pouvons créer des fonctions multi-paramètres en utilisant une technique appelée currying.
+
+- `(λx.λy.λz.xyz)` est équivalent à `f(x, y, z) = x(y(z))`
+
+Parfois, `λxy.<corps>` est utilisé de manière interchangeable avec: `λx.λy.<corps>`
+
+----
+
+Il est important de reconnaître que le lambda-calcul traditionnel n'a pas de nombres, de caractères ou tout autre type de données sans fonction!
+
+## Logique booléenne :
+
+Il n'y a pas de "Vrai" ou de "Faux" dans le calcul lambda. Il n'y a même pas 1 ou 0.
+
+Au lieu:
+
+`T` est représenté par: `λx.λy.x`
+
+`F` est représenté par: `λx.λy.y`
+
+Premièrement, nous pouvons définir une fonction "if" `λbtf` qui renvoie `t` si `b` est vrai et `f` si `b` est faux
+
+`IF` est équivalent à: `λb.λt.λf.b t f`
+
+En utilisant `IF`, nous pouvons définir les opérateurs logiques de base booléens:
+
+`a AND b` est équivalent à: `λab.IF a b F`
+
+`a OR b` est équivalent à: `λab.IF a T b`
+
+`a NOT b` est équivalent à: `λa.IF a F T`
+
+*Note: `IF a b c` est equivalent à : `IF(a(b(c)))`*
+
+## Nombres :
+
+Bien qu'il n'y ait pas de nombres dans le lambda-calcul, nous pouvons encoder des nombres en utilisant les [nombres de Church](https://en.wikipedia.org/wiki/Church_encoding).
+
+Pour tout nombre n: <code>n = λf.f<sup>n</sup></code> donc:
+
+`0 = λf.λx.x`
+
+`1 = λf.λx.f x`
+
+`2 = λf.λx.f(f x)`
+
+`3 = λf.λx.f(f(f x))`
+
+Pour incrémenter un nombre de Church, nous utilisons la fonction successeur `S(n) = n + 1` qui est:
+
+`S = λn.λf.λx.f((n f) x)`
+
+En utilisant `S`, nous pouvons définir la fonction `ADD`:
+
+`ADD = λab.(a S)n`
+
+**Défi:** essayez de définir votre propre fonction de multiplication!
+
+## Pour aller plus loin :
+
+1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)
+2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html)
+3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 48d24549..7b4864b5 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: make
+category: tool
+tool: make
 contributors:
     - ["Robert Steed", "https://github.com/robochat"]
 translators:
diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index 8518f35c..26c2546a 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -6,52 +6,69 @@ filename: markdown-fr.md
 lang: fr-fr
 ---
 
+
 Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
-facile à lire et à écrire, aisément convertible en HTML
- (et beaucoup d'autres formats aussi à présent).
+facile à lire et à écrire, aisément convertible en HTML (et dans beaucoup
+d'autres formats aussi).
+
+Les implémentations du Markdown varient d'un analyseur syntaxique à un autre.
+Ce guide va essayer de clarifier quand une fonctionnalité est universelle ou
+quand elle est specifique à un certain analyseur syntaxique.
+
+- [Balises HTML](#balises-html)
+- [En-têtes](#en-tetes)
+- [Styles de texte basiques](#style-de-text-basiques)
+- [Paragraphes](#paragraphes)
+- [Listes](#listes)
+- [Blocs de code](#blocs-de-code)
+- [Séparateur horizontal](#separateur-horizontal)
+- [Liens hypertextes](#liens-hypertextes)
+- [Images](#images)
+- [Divers](#divers)
 
-Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
-et envoyer des pull request!
+## Balises HTML
 
+Markdown est un sur-ensemble du HTML, donc tout fichier HTML est un ficher
+Markdown valide.
 
 ```md
-<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
-est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
-balises HTML dans un fichier Markdown, comme la balise commentaire dans 
-laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
-le parser( analyseur syntaxique ) Markdown. -->
+<!-- Ce qui veut dire que vous pouvez utiliser des balises HTML dans un fichier
+Markdown, comme la balise commentaire dans laquelle nous sommes à présent, car
+celle-ci ne sera pas affectée par l'analyseur syntaxique du Markdown.
+Toutefois, si vous voulez créer une balise HTML dans un fichier Markdown,
+vous ne pourrez pas utiliser du Markdown à l'intérieur de cette derniere. -->
+```
 
-<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
- vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+## En-têtes
 
-<!--  Le Markdown est implémenté de différentes manières, selon le parser. 
-Ce guide va alors tenter de trier les fonctionnalités universelles de celles
-spécifiques à un parser.  -->
+Vous pouvez facilement créer des balises HTML `<h1>` à `<h6>` en précédant le
+texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six, selon
+le niveau de titre souhaité.
 
-<!-- Headers ( En-têtes ) -->
-<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant
- le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six,
-  selon le niveau de titre souhaité. -->
+```md
 # Ceci est un <h1>
 ## Ceci est un <h2>
 ### Ceci est un <h3>
 #### Ceci est un <h4>
 ##### Ceci est un <h5>
 ###### Ceci est un <h6>
+```
 
-<!-- 
-Markdown fournit également une façon alternative de marquer les h1 et h2 
--->
+Markdown fournit également une façon alternative de marquer les `<h1>` et `<h2>`
 
+```md
 Ceci est un h1
 =============
 
 Ceci est un h2
 -------------
+```
+
+## Styles de texte basiques
 
-<!-- Styles basiques pour du texte -->
-<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown -->
+On peut facilement rendre un texte "gras" ou "italique" en Markdown.
 
+```md
 *Ce texte est en italique.*
 _Celui-ci aussi._
 
@@ -61,15 +78,21 @@ __Celui-là aussi.__
 ***Ce texte a les deux styles.***
 **_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 texte barré.
 
-~~Ce texte est barré avec strikethrough.~~
+```md
+~~Ce texte est barré.~~
+```
+
+## Paragraphes
 
-<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
-séparées par une ou plusieurs lignes vides. -->
+Les paragraphes sont représentés par une ou plusieurs lignes de texte séparées
+par une ou plusieurs lignes vides.
 
+```md
 Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
 
 Maintenant je suis dans le paragraphe 2.
@@ -77,21 +100,23 @@ Je suis toujours dans le paragraphe 2!
 
 
 Puis là, eh oui, le paragraphe 3!
+```
 
-<!--  
-Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter 
-un ou plusieurs espaces à la fin de votre paragraphe, et en commencer 
-un nouveau.
--->
+Si jamais vous souhaitez insérer une balise HTML `<br />`, vous pouvez ajouter
+un ou plusieurs espaces à la fin de votre paragraphe, et en commencer un
+nouveau.
 
-J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
+```md
+J'ai deux espaces vides à la fin (sélectionnez moi pour les voir).
 
 Bigre, il y a un <br /> au dessus de moi!
+```
 
-<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > -->
+Les blocs de citations sont générés aisément, grâce au caractère `>`.
 
+```md
 > Ceci est une superbe citation. Vous pouvez même
-> revenir à la ligne quand ça vous chante, et placer un `>` 
+> revenir à la ligne quand ça vous chante, et placer un `>`
 > devant chaque bout de ligne faisant partie
 > de la citation.
 > La taille ne compte pas^^ tant que chaque ligne commence par un `>`.
@@ -99,191 +124,244 @@ Bigre, il y a un <br /> au dessus de moi!
 > Vous pouvez aussi utiliser plus d'un niveau
 >> d'imbrication!
 > Classe et facile, pas vrai?
+```
+
+## Listes
 
-<!-- les Listes -->
-<!-- les Listes non ordonnées sont marquées par des asterisques, 
-signes plus ou signes moins. -->
+Les listes non ordonnées sont marquées par des asterisques, signes plus ou
+signes moins.
 
+```md
 * Item
 * Item
 * Un autre item
+```
 
 ou
 
+```md
 + Item
 + Item
 + Encore un item
+```
 
 ou
 
+```md
 - Item
 - Item
 - Un dernier item
+```
 
-<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point -->
+Les listes ordonnées sont générées via un nombre suivi d'un point.
 
+```md
 1. Item un
 2. Item deux
 3. Item trois
+```
 
-<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera 
-les bons chiffres. Ceci dit, cette variante perd en clarté.-->
+Vous pouvez même vous passer de tout numéroter, et Markdown générera les bons
+chiffres. Ceci dit, cette variante perd en clarté.
 
+```md
 1. Item un
 1. Item deux
 1. Item trois
-<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) -->
+```
+
+(Cette liste sera interprétée de la même façon que celle au dessus)
 
-<!-- Vous pouvez également utiliser des sous-listes -->
+Vous pouvez également utiliser des sous-listes.
 
+```md
 1. Item un
 2. Item deux
 3. Item trois
 * Sub-item
 * Sub-item
 4. Item quatre
+```
 
-<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML 
-de type checkbox. -->
-
-Les [ ] ci dessous, n'ayant pas de [ x ], 
-deviendront des cases à cocher HTML non-cochées.
+Il y a même des listes de taches. Elles génèrent des champs HTML de type case à
+cocher.
 
+```md
+Les [ ] ci-dessous, n'ayant pas de [ x ], deviendront des cases à cocher HTML
+non-cochées.
 - [ ] Première tache à réaliser.
 - [ ] Une autre chose à faire.
 La case suivante sera une case à cocher HTML cochée.
 - [x] Ça ... c'est fait!
+```
 
-<!-- les Blocs de Code -->
-<!-- Pour marquer du texte comme étant du code, il suffit de commencer 
-chaque ligne en tapant 4 espaces (ou un Tab) -->
+## Blocs de code
 
+Pour marquer du texte comme étant du code (qui utilise la balise `<code>`), il
+suffit d'indenter chaque ligne avec 4 espaces ou une tabulation.
+
+```md
     echo "Ça, c'est du Code!";
     var Ça = "aussi !";
+```
 
-<!-- L'indentation par tab ou série de quatre espaces 
-fonctionne aussi à l'intérieur du bloc de code -->
+L'indentation par tabulation (ou série de quatre espaces) fonctionne aussi à
+l'intérieur du bloc de code.
 
+```md
     my_array.each do |item|
        puts item
     end
+```
 
-<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
+Des bouts de code en mode en ligne s'ajoutent en utilisant le caractères
+`` ` ``.
 
+```md
 La fonction `run()` ne vous oblige pas à aller courir!
+```
+
+En Markdown GitHub, vous pouvez utiliser des syntaxes spécifiques.
 
-<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
-des syntaxes spécifiques -->
+    ```ruby 
+    def foobar
+    puts "Hello world!"
+    end
+    ```
 
-\`\`\`ruby 
-<!-- mais enlevez les backslashes quand vous faites ça, 
-gardez juste ```ruby ( ou nom de la syntaxe correspondant à votre code )-->
-def foobar
-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 
+va utiliser une coloration syntaxique pour le langage indiqué après les ```.
 
-<-- 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
 
-<!-- Ligne Horizontale (<hr />) -->
-<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
-avec ou sans espaces entre chaque un. -->
+Pour insérer une ligne horizontale, utilisez trois ou plusieurs astérisques ou tirets, avec ou sans espaces entre.
 
+```md
 ***
 ---
 - - -
 ****************
+```
 
-<!-- Liens -->
-<!-- Une des fonctionnalités sympathiques du Markdown est la facilité 
-d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), 
-et voilà l'travail.
--->
+## Liens hypertextes
 
+Une des fonctionnalités sympathiques du Markdown est la facilité d'ajouter des
+liens hypertextes. Le texte du lien entre crochet `` [] ``, l'url entre
+parenthèses `` () ``, et voilà le travail.
+
+```md
 [Clic moi!](http://test.com/)
+```
 
-<!-- 
-Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. 
--->
+Pour ajouter un attribut `Title`, collez-le entre guillemets, avec le lien.
 
+```md
 [Clic moi!](http://test.com/ "Lien vers Test.com")
+```
 
-<!-- les Liens Relatifs marchent aussi -->
+Markdown supporte aussi les liens relatifs.
 
+```md
 [En avant la musique](/music/).
+```
 
-<!-- Les liens façon "références" sont eux aussi disponibles en Markdown -->
+Les liens de références sont eux aussi disponibles en Markdown.
 
+```md
 [Cliquez ici][link1] pour plus d'information!
 [Regardez aussi par ici][foobar] si vous voulez.
 
 [link1]: http://test.com/ "Cool!"
-[foobar]: http://foobar.biz/ "Alright!"
+[foobar]: http://foobar.biz/ "Génial!"
+```
 
-<!--  Le titre peut aussi être entouré de guillemets simples, 
-entre parenthèses ou absent. Les références peuvent être placées 
-un peu où vous voulez dans le document, et les identifiants 
-(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
+Le titre peut aussi être entouré de guillemets simples, ou de parenthèses, ou
+absent. Les références peuvent être placées où vous voulez dans le document et
+les identifiants peuvent être n'importe quoi tant qu'ils sont uniques.
 
-<!-- Il y a également le "nommage implicite" qui transforme le texte du lien
- en identifiant -->
+Il y a également le nommage implicite qui transforme le texte du lien en
+identifiant.
 
+```md
 [Ceci][] est un lien.
 
 [ceci]: http://ceciestunlien.com/
+```
+
+Mais ce n'est pas beaucoup utilisé.
 
-<!-- mais ce n'est pas beaucoup utilisé. -->
+## Images
 
-<!-- Images -->
-<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée
- d'un point d'exclamation! -->
+Pour les images, la syntaxe est identique à celle des liens, sauf que précédée
+d'un point d'exclamation!
 
+```md
 ![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
+```
+
+Là aussi, on peut utiliser le mode "références".
 
-<!-- Là aussi, on peut utiliser le mode "références" -->
 
+```md
 ![Ceci est l'attribut ALT de l'image][monimage]
 
 [monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
+```
+
+## Divers
 
-<!-- Divers -->
-<!-- Liens Automatiques -->
+### Liens Automatiques
 
+```md
 <http://testwebsite.com/> est équivalent à :
 [http://testwebsite.com/](http://testwebsite.com/)
+```
 
-<!-- Liens Automatiques pour emails -->
+### Liens Automatiques pour emails
 
+```md
 <foo@bar.com>
+```
+
+### Caracteres d'echappement
 
-<!-- Escaping -->
-Il suffit de précéder les caractères spécifiques à ignorer par des backslash \
+Il suffit de précéder les caractères spécifiques à ignorer par des backslash `\`.
 
-Pour taper *ce texte* entouré d'astérisques mais pas en italique : 
+```md
+Pour taper *ce texte* entouré d'astérisques mais pas en italique :
 Tapez \*ce texte\*.
+```
+
+### Touches de clavier
 
-<!-- Tableaux -->
-<!-- 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 :
- -->
+Avec le "Github Flavored Markdown", vous pouvez utiliser la balise `<kdb>`
+pour représenter une touche du clavier.
 
+```md
+Ton ordinateur a planté? Essayer de taper :
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
+
+### Tableaux
+
+Les tableaux ne sont disponibles que dans le "GitHub Flavored Markdown" et
+ne sont pas tres agréable d'utilisation. Mais si vous en avez besoin :
+
+```md
 | Col1 | Col2 | Col3 |
 | :----------- | :------: | ------------: |
-| Alignement Gauche | Centé | Alignement Droite |
+| Alignement Gauche | Centré | Alignement Droite |
 | bla | bla | bla |
+```
 
-<!-- ou bien, pour un résultat équivalent : -->
+ou bien, pour un résultat équivalent :
 
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 Ough que c'est moche | svp | arrêtez
-
-<!-- Fin! -->
-
 ```
 
-Pour plus d'information :
- consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, 
- et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
+Pour plus d'information, consultez le post officiel de Jhon Gruber à propos de
+la syntaxe [ici](http://daringfireball.net/projects/markdown/syntax) et la
+superbe fiche pense-bête de Adam Pritchard [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/fr-fr/pyqt-fr.html.markdown b/fr-fr/pyqt-fr.html.markdown
new file mode 100644
index 00000000..6da9a380
--- /dev/null
+++ b/fr-fr/pyqt-fr.html.markdown
@@ -0,0 +1,85 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-fr.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["DevHugo", "http://twitter.com/devhugo"]
+lang: fr-fr
+---
+
+**Qt** est un framework très connu pour le développement de logiciel cross-platform qui peuvent être lancé sur différents systèmes avec de petit ou aucun changement dans le code, tout en ayant la puissance et la vitesse des applications natives. Bien que **Qt** ait été écrit à l'origine en *C++*.
+
+
+Ceci est une adaptation de l'intro C++ à QT par [Aleksey Kholovchuk](https://github.com/vortexxx192
+), certains exemples du code doivent avoir la même fonctionnalité,
+cette version ayant juste été faite en utilisant pyqt! 
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+	# Création de l'objet application 
+    app = QtGui.QApplication(sys.argv)
+	# Création d'un widget où notre label sera placé
+    w = QtGui.QWidget()
+	# Ajout d'un label au widget
+    b = QtGui.QLabel(w)
+	# Assignation de texte au label
+    b.setText("Hello World!")
+	# Assignation des tailles et des informations de placement
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+	# Assignation d'un nom à notre fenêtre
+    w.setWindowTitle("PyQt")
+	# Affichage de la fenêtre
+    w.show()
+	# Exécution de l'application
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+Pour obtenir certaines des fonctionnalités les plus avancées de **pyqt** nous devons commencer par chercher à construire des éléments supplémentaires.
+Ici nous voyons comment introduire une boîte de dialogue popup, utile pour demander une confirmation à un utilisateur ou fournir des informations.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Creation d'un bouton attaché au widget w
+    b = QPushButton(w)
+    b.setText("Press me")
+    b.move(50, 50)
+    # Dire à b d'appeler cette fonction quand il est cliqué
+    # remarquez l'absence de "()" sur l'appel de la fonction
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# Cette fonction devrait créer une fenêtre de dialogue avec un bouton
+# qui attend d'être cliqué puis quitte le programme
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Cette modalité dit au popup de bloquer le parent pendant qu'il est actif
+    d.setWindowModality(Qt.ApplicationModal)
+    # En cliquant je voudrais que tout le processus se termine
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index d78291be..0ae410de 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -444,7 +444,7 @@ Human.grunt() #=> "*grunt*"
 
 # On peut importer des modules
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Et récupérer des fonctions spécifiques d'un module
 from math import ceil, floor