Merge pull request #1 from adambard/master

ff

14 files changed, 633 insertions, 327 deletions

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/crystal-fr.html.markdown b/fr-fr/crystal-fr.html.markdown
index 2c4e3dad..2bb17fc5 100644
--- a/fr-fr/crystal-fr.html.markdown
+++ b/fr-fr/crystal-fr.html.markdown
@@ -305,7 +305,6 @@ end
 (1..3).each do |index|
   puts "Index: #{index}"
 end
-# Index: 0
 # Index: 1
 # Index: 2
 # Index: 3
diff --git a/fr-fr/d.html.markdown b/fr-fr/d-fr.html.markdown
index 8d98f9dc..8d98f9dc 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d-fr.html.markdown
diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
index 24e8c95f..54cca001 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/haskell.html.markdown b/fr-fr/haskell-fr.html.markdown
index a34dc098..a34dc098 100644
--- a/fr-fr/haskell.html.markdown
+++ b/fr-fr/haskell-fr.html.markdown
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/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
new file mode 100644
index 00000000..b3b7de85
--- /dev/null
+++ b/fr-fr/markdown-fr.html.markdown
@@ -0,0 +1,367 @@
+---
+language: markdown
+contributors:
+- ["Andrei Curelaru", "http://www.infinidad.fr"]
+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 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)
+
+## Balises HTML
+
+Markdown est un sur-ensemble du HTML, donc tout fichier HTML est un ficher
+Markdown valide.
+
+```md
+<!-- 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. -->
+```
+
+## En-têtes
+
+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é.
+
+```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>`
+
+```md
+Ceci est un h1
+=============
+
+Ceci est un h2
+-------------
+```
+
+## Styles de texte basiques
+
+On peut facilement rendre un texte "gras" ou "italique" en Markdown.
+
+```md
+*Ce texte est en italique.*
+_Celui-ci aussi._
+
+**Ce texte est en gras.**
+__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 texte barré.
+
+```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.
+
+```md
+Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
+
+Maintenant je suis dans le paragraphe 2.
+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.
+
+```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 `>`.
+
+```md
+> Ceci est une superbe citation. Vous pouvez même
+> 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 `>`.
+
+> Vous pouvez aussi utiliser plus d'un niveau
+>> d'imbrication!
+> Classe et facile, pas vrai?
+```
+
+## Listes
+
+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.
+
+```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é.
+
+```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)
+
+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 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!
+```
+
+## 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 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 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.
+
+    ```ruby 
+    def foobar
+    puts "Hello world!"
+    end
+    ```
+
+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
+
+Pour insérer une ligne horizontale, utilisez trois ou plusieurs astérisques ou tirets, avec ou sans espaces entre.
+
+```md
+***
+---
+- - -
+****************
+```
+
+## 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.
+
+```md
+[Clic moi!](http://test.com/ "Lien vers Test.com")
+```
+
+Markdown supporte aussi les liens relatifs.
+
+```md
+[En avant la musique](/music/).
+```
+
+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/ "Génial!"
+```
+
+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.
+
+```md
+[Ceci][] est un lien.
+
+[ceci]: http://ceciestunlien.com/
+```
+
+Mais ce n'est pas beaucoup utilisé.
+
+## Images
+
+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".
+
+
+```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
+
+### Liens Automatiques
+
+```md
+<http://testwebsite.com/> est équivalent à :
+[http://testwebsite.com/](http://testwebsite.com/)
+```
+
+### Liens Automatiques pour emails
+
+```md
+<foo@bar.com>
+```
+
+### Caracteres d'echappement
+
+Il suffit de précéder les caractères spécifiques à ignorer par des backslash `\`.
+
+```md
+Pour taper *ce texte* entouré d'astérisques mais pas en italique :
+Tapez \*ce texte\*.
+```
+
+### Touches de clavier
+
+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 |
+| bla | bla | bla |
+```
+
+ou bien, pour un résultat équivalent :
+
+```md
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ough que c'est moche | svp | arrêtez
+```
+
+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/markdown.html.markdown b/fr-fr/markdown.html.markdown
deleted file mode 100644
index 2e4e8461..00000000
--- a/fr-fr/markdown.html.markdown
+++ /dev/null
@@ -1,289 +0,0 @@
----
-language: markdown
-contributors:
-- ["Andrei Curelaru", "http://www.infinidad.fr"]
-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).
-
-Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
-et envoyer des pull request!
-
-
-```markdown
-<!-- 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. -->
-
-<!-- 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. -->
-
-<!--  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.  -->
-
-<!-- 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é. -->
-# 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 
--->
-
-Ceci est un h1
-=============
-
-Ceci est un h2
--------------
-
-<!-- Styles basiques pour du texte -->
-<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown -->
-
-*Ce texte est en italique.*
-_Celui-ci aussi._
-
-**Ce texte est en gras.**
-__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é ) : -->
-
-~~Ce texte est barré avec strikethrough.~~
-
-<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
-séparées par une ou plusieurs lignes vides. -->
-
-Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
-
-Maintenant je suis dans le paragraphe 2.
-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.
--->
-
-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 > -->
-
-> Ceci est une superbe citation. Vous pouvez même
-> 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 `>`.
-
-> Vous pouvez aussi utiliser plus d'un niveau
->> d'imbrication!
-> Classe et facile, pas vrai?
-
-<!-- les Listes -->
-<!-- les Listes non ordonnées sont marquées par des asterisques, 
-signes plus ou signes moins. -->
-
-* Item
-* Item
-* Un autre item
-
-ou
-
-+ Item
-+ Item
-+ Encore un item
-
-ou
-
-- Item
-- Item
-- Un dernier item
-
-<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point -->
-
-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é.-->
-
-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 ) -->
-
-<!-- Vous pouvez également utiliser des sous-listes -->
-
-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.
-
-- [ ] 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) -->
-
-    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 -->
-
-    my_array.each do |item|
-       puts item
-    end
-
-<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
-
-La fonction `run()` ne vous oblige pas à aller courir!
-
-<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
-des syntaxes spécifiques -->
-
-\`\`\`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 ``` -->
-
-<!-- Ligne Horizontale (<hr />) -->
-<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
-avec ou sans espaces entre chaque un. -->
-
-***
----
-- - -
-****************
-
-<!-- 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.
--->
-
-[Clic moi!](http://test.com/)
-
-<!-- 
-Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. 
--->
-
-[Clic moi!](http://test.com/ "Lien vers Test.com")
-
-<!-- les Liens Relatifs marchent aussi -->
-
-[En avant la musique](/music/).
-
-<!-- Les liens façon "références" sont eux aussi disponibles en Markdown -->
-
-[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!"
-
-<!--  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 -->
-
-<!-- Il y a également le "nommage implicite" qui transforme le texte du lien
- en identifiant -->
-
-[Ceci][] est un lien.
-
-[ceci]: http://ceciestunlien.com/
-
-<!-- mais ce n'est pas beaucoup utilisé. -->
-
-<!-- Images -->
-<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée
- d'un point d'exclamation! -->
-
-![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
-
-<!-- Là aussi, on peut utiliser le mode "références" -->
-
-![Ceci est l'attribut ALT de l'image][monimage]
-
-[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
-
-<!-- Divers -->
-<!-- Liens Automatiques -->
-
-<http://testwebsite.com/> est équivalent à :
-[http://testwebsite.com/](http://testwebsite.com/)
-
-<!-- Liens Automatiques pour emails -->
-
-<foo@bar.com>
-
-<!-- Escaping -->
-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 : 
-Tapez \*ce texte\*.
-
-<!-- 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 :
- -->
-
-| Col1 | Col2 | Col3 |
-| :----------- | :------: | ------------: |
-| Alignement Gauche | Centé | Alignement Droite |
-| bla | bla | bla |
-
-<!-- ou bien, pour un résultat équivalent : -->
-
-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.
diff --git a/fr-fr/php.html.markdown b/fr-fr/php-fr.html.markdown
index 823630bd..45a02d75 100644
--- a/fr-fr/php.html.markdown
+++ b/fr-fr/php-fr.html.markdown
@@ -6,10 +6,11 @@ contributors:
     - ["Trismegiste", "https://github.com/Trismegiste"]
 translators:
     - ["Pascal Boutin", "http://pboutin.net/"]
+    - ["Julien M'Poy", "https://github.com/groovytron"]
 lang: fr-fr
 ---
 
-This document describes PHP 5+.
+Ce document décrit PHP 5+.
 
 ```php
  // Le code PHP doit être placé à l'intérieur de balises '<?php'
@@ -48,7 +49,7 @@ Hello World Again!
 // Un nom de variable valide commence par une lettre ou un souligné,
 // suivi de n'importe quelle lettre, nombre ou de soulignés.
 
-// Les valeurs booléenes ne sont pas sensibles à la casse
+// Les valeurs booléennes ne sont pas sensibles à la casse
 $boolean = true;  // ou TRUE ou True
 $boolean = false; // ou FALSE ou False
 
@@ -84,30 +85,30 @@ $number /= $float; // Divise et assigne le quotient à $number
 $sgl_quotes = '$String'; // => '$String'
 
 // Évitez les guillemets sauf pour inclure le contenu d'une autre variable
-$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
+$dbl_quotes = "Ceci est une $sgl_quotes."; // => 'Ceci est une $String.'
 
 // Les caractères spéciaux sont seulement échappés avec des guillemets
-$escaped   = "This contains a \t tab character.";
-$unescaped = 'This just contains a slash and a t: \t';
+$escaped   = "Ceci contient \t une tabulation.";
+$unescaped = 'Ceci contient juste un slash et un t: \t';
 
 // En cas de besoin, placez la variable dans des accolades
-$money = "I have $${number} in the bank.";
+$money = "J'ai $${number} sur mon compte en banque.";
 
 // Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes
 // multi-lignes non-interprétées
 $nowdoc = <<<'END'
-Multi line
-string
+String
+mutli-lignes
 END;
 
 // Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées
 $heredoc = <<<END
-Multi line
 $sgl_quotes
+multi-lignes
 END;
 
 // La concaténation de chaînes se fait avec un .
-echo 'This string ' . 'is concatenated';
+echo 'Cette string ' . 'est concatenée'; // => 'Cette string est concaténée'
 
 
 /********************************
@@ -122,7 +123,7 @@ echo 'This string ' . 'is concatenated';
 define("FOO",     "something");
 
 // on peut accéder à une constante en utilisant directement son nom
-echo 'This outputs '.FOO;
+echo 'Ceci affiche ' . FOO;
 
 
 /********************************
@@ -149,6 +150,14 @@ $array[] = 'Four';
 // Retrait d'un élément du tableau
 unset($array[3]);
 
+// Depuis PHP 7, il est possible de déclarer des tableaux constants en
+// utilisant 'define'.
+define('ANIMAUX', [
+    'chien',
+    'chat',
+    'oiseau',
+]);
+
 /********************************
  * Affichage
  */
@@ -159,11 +168,13 @@ echo('Hello World!');
 
 print('Hello World!'); // Pareil à "écho"
 
-// Pour écho, vous n'avez pas besoin des parenthèses
+// 'echo' et 'print' sont des language constructs.
+// Il n'ont pas besoin de parenthèses car ils sont traités comme
+// des opérateurs unaires.
 echo 'Hello World!';
-print 'Hello World!'; // Pour print non plus
+print 'Hello World!'; 
 
-$paragraph = 'paragraph';
+$paragraph = 'paragraphe';
 
 echo 100;        // Affichez un scalaire directement
 echo $paragraph; // ou des variables
@@ -202,7 +213,8 @@ $b = '0';
 $c = '1';
 $d = '1';
 
-// assert affiche un avertissement dans son argument n'est pas vrai
+// assert affiche un avertissement quand l'expression booléenne passée
+// en argument n'est pas vraie.
 
 // Ces comparaisons vont toujours être vraies, même si leurs
 // types ne sont pas les mêmes.
@@ -315,7 +327,7 @@ if ($x === '0') {
 switch ($x) {
     case '0':
         print 'Les switch font du transtypage implicite';
-        break; // Il est important de déclaré un 'break', sinon les cas
+        break; // Il est important de déclarer un 'break', sinon les cas
                // 'two' et 'three' seront évalués
     case 'two':
     case 'three':
@@ -390,9 +402,10 @@ function my_function () {
 echo my_function(); // => "Hello"
 
 
-// Les noms de fonction débutent par le symbole $
-// Un nom de variable valide commence par une lettre ou un souligné,
+// Un nom de fonction valide commence par une lettre ou un souligné,
 // suivi de n'importe quelle lettre, nombre ou de soulignés.
+// Les noms des arguments d'une fonction doivent respecter le même format que
+// celui des variables.
 
 function add ($x, $y = 1) { // $y est facultatif et sa valeur par défaut est 1
   $result = $x + $y;
@@ -519,7 +532,7 @@ class MyClass
 
     public static function myStaticMethod()
     {
-        print 'I am static';
+        print 'Je suis static';
     }
 }
 
@@ -527,7 +540,7 @@ class MyClass
 echo MyClass::MY_CONST;    // Outputs 'value';
 
 echo MyClass::$staticVar;  // Retourne 'static';
-MyClass::myStaticMethod(); // Retourne 'I am static';
+MyClass::myStaticMethod(); // Retourne 'Je suis static';
 
 // On peut instancier une classe en utilisant le mot clé 'new'
 $my_class = new MyClass('An instance property');
@@ -584,7 +597,7 @@ echo $x->property; // Va utiliser la méthode __get()
 $x->property = 'Something'; // Va utiliser la méthode __set()
 
 // Les classes peuvent être abstraites (en utilisant le mot clé 'abstract'), ou
-// elle peuvent implémenter une interface (en utilisant le mot clé 'implement').
+// elle peuvent implémenter une interface (en utilisant le mot clé 'implements').
 
 // Une interface peut être déclarée avec le mot clé 'interface'
 
@@ -637,6 +650,35 @@ class SomeOtherClass implements InterfaceOne, InterfaceTwo
     }
 }
 
+// Il est possible de déclarer des classes internes anonymes depuis PHP 7
+
+interface Logger {
+    public function log(string $msg);
+}
+
+class Application {
+    private $logger;
+
+    public function getLogger(): Logger {
+         return $this->logger;
+    }
+
+    public function setLogger(Logger $logger) {
+         $this->logger = $logger;
+    }
+}
+
+$app = new Application;
+
+$app->setLogger(new class implements Logger {
+    public function log(string $msg) {
+        echo $msg;
+    }
+});
+
+var_dump($app->getLogger()); // => 'object(class@anonymous)#2 (0) {}'
+
+
 /********************************
  * Espaces de noms (namespaces)
  */
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/scala.html.markdown b/fr-fr/scala-fr.html.markdown
index c6a61745..c6a61745 100644
--- a/fr-fr/scala.html.markdown
+++ b/fr-fr/scala-fr.html.markdown
diff --git a/fr-fr/vim.html.markdown b/fr-fr/vim-fr.html.markdown
index b2f1d24d..b2f1d24d 100644
--- a/fr-fr/vim.html.markdown
+++ b/fr-fr/vim-fr.html.markdown