From 18058567c4e7570ca7fd053299eefd0d36658329 Mon Sep 17 00:00:00 2001
From: Matteo Taroli <taroli.matteo@gmail.com>
Date: Fri, 2 Oct 2015 22:17:16 +0200
Subject: Add French translation for Perl 5

---
 fr-fr/perl-fr.html.markdown | 166 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 166 insertions(+)
 create mode 100644 fr-fr/perl-fr.html.markdown

diff --git a/fr-fr/perl-fr.html.markdown b/fr-fr/perl-fr.html.markdown
new file mode 100644
index 00000000..7a061da7
--- /dev/null
+++ b/fr-fr/perl-fr.html.markdown
@@ -0,0 +1,166 @@
+---
+name: perl
+category: language
+language: perl
+filename: learnperl-fr.pl
+contributors:
+    - ["Korjavin Ivan", "http://github.com/korjavin"]
+translators:
+    - ["Matteo Taroli", "http://www.matteotaroli.be"]
+lang: fr-fr
+---
+Perl 5 est un langage de programmation riche en fonctionnalité, avec plus de 25 ans de développement.
+
+Perl 5 fonctionne sur plus de 100 plateformes, allant des pc portables aux mainframes et
+est autant adapté à un prototypage rapide qu'à des projets de grande envergure.
+
+```perl
+#  Les commentaires en une ligne commencent par un dièse
+
+
+#### Types de variables de Perl
+
+# Les variables comment par un symbole précisant le type.
+# Un nom de variable valide commence par une lettre ou un underscore,
+# suivi d'un nombre quelconque de lettres, chiffres ou underscores.
+
+### Perl a trois types principaux de variables: $scalaire, @tableau and %hash
+
+## Scalaires
+#  Un scalaire représente une valeure unique :
+my $animal = "chameau";
+my $reponse = 42;
+
+# Les valeurs scalaires peuvent être des strings, des entiers ou des nombres à virgule flottante
+# et Perl les convertira automatiquement entre elles quand nécessaire.
+
+## Tableaux
+#  Un tableau représente une liste de valeurs :
+my @animaux = ("chameau", "lama", "chouette");
+my @nombres = (23, 42, 69);
+my @melange = ("chameau", 42, 1.23);
+
+## Hashes
+#  Un hash représente un ensemble de paires de clé/valeur :
+my %fruit_couleur = ("pomme", "rouge", "banane", "jaune");
+
+# Vous pouvez utiliser des espaces et l'opérateur "=>" pour les disposer plus joliment :
+
+my %fruit_couleur = (
+	pomme  => "rouge",
+	banane => "jaune"
+);
+
+# Les scalaires, tableaux et hashes sont plus amplement documentés dans le perldata
+# (perldoc perldata)
+
+# Des types de données plus complexes peuvent être construits en utilisant des références,
+# vous permettant de construire des listes et des hashes à l'intérieur d'autres listes et hashes.
+
+#### Conditions et boucles
+
+# Perl possède la plupart des conditions et boucles habituelles.
+
+if ($var) {
+  ...
+} elsif ($var eq 'bar') {
+  ...
+} else {
+  ...
+}
+
+unless (condition) {
+  ...
+}
+# Ceci est fourni en tant que version plus lisible de "if (!condition)"
+
+# la postcondition à la sauce Perl
+
+print "Yow!" if $zippy;
+print "Nous n'avons pas de banane." unless $bananes;
+
+#  while
+while (condition) {
+  ...
+}
+
+# boucle for et iteration
+for (my $i = 0; $i < $max; $i++) {
+  print "l'index est $i";
+}
+
+for (my $i = 0; $i < @elements; $i++) {
+  print "L'élément courant est " . $elements[$i];
+}
+
+for my $element (@elements) {
+  print $element;
+}
+
+# implicitement
+
+for (@elements) {
+  print;
+}
+
+
+#### Expressions régulières
+
+# Le support des expressions régulières par Perl est aussi large que profond
+# et est sujet à une longue documentation sur perlrequick, perlretut et ailleurs.
+# Cependant, pour faire court :
+
+# Simple correspondance
+if (/foo/)       { ... }  # vrai si $_ contient "foo"
+if ($a =~ /foo/) { ... }  # vrai si $a contient "foo"
+
+# Simple substitution
+
+$a =~ s/foo/bar/;         # remplace foo par bar dans $a
+$a =~ s/foo/bar/g;        # remplace TOUTES LES INSTANCES de foo par bar dans $a
+
+
+#### Fichiers and E/S
+
+# Vous pouvez ouvrir un fichier pour y écrire ou pour le lire avec la fonction "open()".
+
+open(my $in,  "<",  "input.txt")  or die "Impossible d'ouvrir input.txt: $!";
+open(my $out, ">",  "output.txt") or die "Impossible d'ouvrir output.txt: $!";
+open(my $log, ">>", "my.log")     or die "Impossible d'ouvrir my.log: $!";
+
+# Vous pouvez lire depuis un descripteur de fichier grâce à l'opérateur "<>".
+# Dans un contexte scalaire, il lit une seule ligne depuis le descripteur de fichier
+# et dans un contexte de liste, il lit le fichier complet, assignant chaque ligne à un
+# élément de la liste :
+
+my $ligne = <$in>
+my $lignes = <$in>
+
+#### Ecrire des sous-programmes
+
+# Ecrire des sous-programmes est facile :
+
+sub logger {
+  my $logmessage = shift;
+
+  open my $logfile, ">>", "my.log" or die "Impossible d'ouvrir my.log: $!";
+
+  print $logfile $logmessage;
+}
+
+# Maintenant, nous pouvons utiliser le sous-programme comme n'importe quelle fonction intégrée :
+
+logger("On a un sous-programme de logging!!");
+```
+
+#### Utiliser des modules Perl
+
+Les modules Perl fournissent une palette de fonctionnalités vous évitant de réinventer la roue et peuvent être téléchargés depuis CPAN (http://www.cpan.org/). Un certain nombre de modules populaires sont inclus dans la distribution même de Perl.
+
+Perlfaq contiens des questions et réponses liées aux tâches habituelles et propose souvent des suggestions quant aux bons modules à utiliser.
+
+#### Pour en savoir plus
+ - [perl-tutorial](http://perl-tutorial.org/)
+ - [Learn at www.perl.com](http://www.perl.org/learn.html)
+ - [perldoc](http://perldoc.perl.org/)
+ - and perl built-in : `perldoc perlintro`
-- 
cgit v1.2.3


From b723d3284bbccbcbf5e7ecedee3469b87f4d5959 Mon Sep 17 00:00:00 2001
From: Matteo Taroli <taroli.matteo@gmail.com>
Date: Thu, 8 Oct 2015 12:38:19 +0200
Subject: Add explanation about $_ and fix typos

---
 fr-fr/perl-fr.html.markdown | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/fr-fr/perl-fr.html.markdown b/fr-fr/perl-fr.html.markdown
index 7a061da7..e737b7aa 100644
--- a/fr-fr/perl-fr.html.markdown
+++ b/fr-fr/perl-fr.html.markdown
@@ -5,6 +5,7 @@ language: perl
 filename: learnperl-fr.pl
 contributors:
     - ["Korjavin Ivan", "http://github.com/korjavin"]
+    - ["Matteo Taroli", "http://www.matteotaroli.be"]
 translators:
     - ["Matteo Taroli", "http://www.matteotaroli.be"]
 lang: fr-fr
@@ -27,7 +28,7 @@ est autant adapté à un prototypage rapide qu'à des projets de grande envergur
 ### Perl a trois types principaux de variables: $scalaire, @tableau and %hash
 
 ## Scalaires
-#  Un scalaire représente une valeure unique :
+#  Un scalaire représente une valeur unique :
 my $animal = "chameau";
 my $reponse = 42;
 
@@ -99,8 +100,15 @@ for my $element (@elements) {
 
 # implicitement
 
+# La variable de contexte scalaire $_ est utilisée par défaut dans différentes
+# situations, comme par exemple dans la boucle foreach ou en argument par défaut
+# de la plupart des fonctions pour en simplifier l'écriture.
+
+# Dans l'exemple suivant, $_ prends successivement la valeur de
+# chaque élément de la liste.  
+
 for (@elements) {
-  print;
+  print; # affiche le contenu de $_
 }
 
 
@@ -116,11 +124,11 @@ if ($a =~ /foo/) { ... }  # vrai si $a contient "foo"
 
 # Simple substitution
 
-$a =~ s/foo/bar/;         # remplace foo par bar dans $a
+$a =~ s/foo/bar/;         # remplace le premier foo par bar dans $a
 $a =~ s/foo/bar/g;        # remplace TOUTES LES INSTANCES de foo par bar dans $a
 
 
-#### Fichiers and E/S
+#### Fichiers et E/S
 
 # Vous pouvez ouvrir un fichier pour y écrire ou pour le lire avec la fonction "open()".
 
@@ -136,9 +144,9 @@ open(my $log, ">>", "my.log")     or die "Impossible d'ouvrir my.log: $!";
 my $ligne = <$in>
 my $lignes = <$in>
 
-#### Ecrire des sous-programmes
+#### Ecrire des fonctions
 
-# Ecrire des sous-programmes est facile :
+# Ecrire des fonctions est facile :
 
 sub logger {
   my $logmessage = shift;
@@ -148,9 +156,9 @@ sub logger {
   print $logfile $logmessage;
 }
 
-# Maintenant, nous pouvons utiliser le sous-programme comme n'importe quelle fonction intégrée :
+# Maintenant, nous pouvons utiliser cette fonction comme n'importe quelle fonction intégrée :
 
-logger("On a un sous-programme de logging!!");
+logger("On a une fonction de logging!!");
 ```
 
 #### Utiliser des modules Perl
-- 
cgit v1.2.3


From a65d0fb99ad7faa7469da576938b8d37aca6f859 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A9sar=20Su=C3=A1rez?= <suarez.ortega.cesar@gmail.com>
Date: Sat, 10 Oct 2015 13:07:10 +0200
Subject: Update and fix Spanish brainfuck article

---
 es-es/brainfuck-es.html.markdown | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/es-es/brainfuck-es.html.markdown b/es-es/brainfuck-es.html.markdown
index e33d672d..550511da 100644
--- a/es-es/brainfuck-es.html.markdown
+++ b/es-es/brainfuck-es.html.markdown
@@ -9,8 +9,10 @@ lang: es-es
 ---
 
 Brainfuck (con mayúscula sólo al inicio de una oración) es un
-lenguaje de programación mínimo, computacionalmente universal
-en tamaño con sólo 8 comandos.
+lenguaje de programación extremadamente pequeño, Turing completo con sólo 8 comandos.
+
+Puedes probar brainfuck en tu navegador con [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
 
 ```
 
@@ -18,7 +20,7 @@ Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
 será ignorado.
 
 Brainfuck es representado por un arreglo de 30,000 celdas inicializadas
-en cero y un apuntador en la celda actual.
+en cero y un puntero apuntando la celda actual.
 
 Existen ocho comandos:
 
@@ -26,7 +28,7 @@ Existen ocho comandos:
 - : Decrementa 1 al valor de la celda actual.
 > : Mueve el apuntador a la siguiente celda. (a la derecha)
 < : Mueve el apuntador a la celda anterior. (a la izquierda)
-. : Imprime el valor en ASCII de la celda actual (i.e. 65 = 'A')
+. : Imprime el valor en ASCII de la celda actual (p.e. 65 = 'A')
 , : Lee un caracter como input y lo escribe en la celda actual.
 [ : Si el valor en la celda actual es cero mueve el apuntador
 	hasta el primer ']' que encuentre. Si no es cero sigue a la
@@ -37,7 +39,7 @@ Existen ocho comandos:
 
 [ y ] forman un while. Obviamente, deben estar balanceados.
 
-Ahora unos ejemplos de programas escritos con brainfuck.
+Estos son algunos ejemplos de programas escritos con brainfuck.
 
 ++++++ [ > ++++++++++ < - ] > +++++ .
 
@@ -63,7 +65,7 @@ Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un
 cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre
 terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.).
 
-Ten en mente que los espacios son sólo para fines de legibilidad.
+Ten en cuenta que los espacios son sólo para fines de legibilidad.
 Es lo mismo escribir el ejemplo de arriba que esto:
 ,[>+<-]>.
 
@@ -81,7 +83,7 @@ hasta la próxima vez. Para resolver este problema también incrementamos la
 celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene
 el resultado.
 ```
-Y eso es brainfuck. ¿No tan difícil o sí? Como diversión, puedes escribir
+Y eso es brainfuck. No es tan difícil, ¿verdad? Como diversión, puedes escribir
 tu propio intérprete de brainfuck o tu propio programa en brainfuck. El
 intérprete es relativamente sencillo de hacer, pero si eres masoquista,
-intenta construir tu proprio intérprete de brainfuck... en brainfuck.
+puedes intentar construir tu propio intérprete de brainfuck... en brainfuck.
-- 
cgit v1.2.3


From 5c84b03a49553856049e4d9c677b09c9a7eb9419 Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sun, 18 Oct 2015 18:38:01 +0200
Subject: [css/fr] Corrects some French mistakes

---
 fr-fr/css-fr.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/fr-fr/css-fr.html.markdown b/fr-fr/css-fr.html.markdown
index bdab9715..a3a5cf55 100644
--- a/fr-fr/css-fr.html.markdown
+++ b/fr-fr/css-fr.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: fr-fr
 ---
 
-Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. Mais avec le dévelopement des navigateurs,
+Au début du web, il n'y avait pas d'élements visuels, simplement du texte pur. Mais avec le dévelopement des navigateurs,
 des pages avec du contenu visuel sont arrivées.
 CSS est le langage standard qui existe et permet de garder une séparation entre
 le contenu (HTML) et le style d'une page web.
@@ -16,8 +16,8 @@ le contenu (HTML) et le style d'une page web.
 En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents
 sur une page HTML afin de leur donner des propriétés visuelles différentes.
 
-Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parlons de CSS2.0
-qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateur.
+Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parler de CSS2.0
+qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateurs.
 
 **NOTE :** Vous pouvez tester les effets visuels que vous ajoutez au fur et à mesure du tutoriel sur des sites comme [dabblet](http://dabblet.com/) afin de voir les résultats, comprendre, et vous familiariser avec le langage.
 Cet article porte principalement sur la syntaxe et quelques astuces.
@@ -33,7 +33,7 @@ Cet article porte principalement sur la syntaxe et quelques astuces.
 /* Généralement, la première déclaration en CSS est très simple */
 selecteur { propriete: valeur; /* autres proprietés...*/ }
 
-/* Le sélécteur sert à cibler un élément du HTML
+/* Le sélecteur sert à cibler un élément du HTML
 
 Vous pouvez cibler tous les éléments d'une page! */
 * { color:red; }
@@ -81,7 +81,7 @@ div.une-classe[attr$='eu'] { }
 /* Un élément qui est en enfant direct */
 div.un-parent > .enfant {}
 
-/* Cela cible aussi les .enfants plus profonds dans la structure HTML */
+/*  dans la structure HTML */
 div.un-parent .enfants {}
 
 /* Attention : le même sélecteur sans espace a un autre sens. */
-- 
cgit v1.2.3


From fe4ed9080dc258e35a9fffd3a52d097eb457c745 Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sun, 18 Oct 2015 18:39:21 +0200
Subject: Brings text back

---
 fr-fr/css-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fr-fr/css-fr.html.markdown b/fr-fr/css-fr.html.markdown
index a3a5cf55..35673c47 100644
--- a/fr-fr/css-fr.html.markdown
+++ b/fr-fr/css-fr.html.markdown
@@ -81,7 +81,7 @@ div.une-classe[attr$='eu'] { }
 /* Un élément qui est en enfant direct */
 div.un-parent > .enfant {}
 
-/*  dans la structure HTML */
+/* Cela cible aussi les .enfants plus profonds dans la structure HTML */
 div.un-parent .enfants {}
 
 /* Attention : le même sélecteur sans espace a un autre sens. */
-- 
cgit v1.2.3


From a8ebd498338183f3469e37f7763aad6d644780e1 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:34:59 +0200
Subject: [d/fr] adds translation

---
 fr-fr/d.html.markdown | 291 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 291 insertions(+)
 create mode 100644 fr-fr/d.html.markdown

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
new file mode 100644
index 00000000..dfc3519d
--- /dev/null
+++ b/fr-fr/d.html.markdown
@@ -0,0 +1,291 @@
+---
+language: D
+filename: learnd.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+	- ["Quentin Ladeveze", "aceawan.eu"]
+lang: fr
+---
+
+```d
+// Commençons par un classique
+module hello;
+
+import std.stdio;
+
+// args n'est pas obligatoire
+void main(string[] args) {
+    writeln("Bonjour le monde !");
+}
+```
+
+Si vous êtes comme moi et que vous passez beaucoup trop de temps sur internet, il y a
+de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.org/).
+D est un langage de programmation moderne, généraliste, multi-paradigme qui contient
+des fonctionnalités aussi bien de bas-niveau que haut-niveau.
+
+D is actively developed by a large group of super-smart people and is spearheaded by
+[Walter Bright](https://en.wikipedia.org/wiki/Walter_Bright) and
+[Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
+With all that out of the way, let's look at some examples!
+
+D est activement développé par de nombreuses personnes très intelligents, guidées par
+[Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et
+[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
+Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
+
+```d
+import std.stdio;
+
+void main() {
+
+	//Les conditions et les boucles sont classiques.
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+	// On peut utiliser auto pour inférer automatiquement le
+	// type d'une variable.
+    auto n = 1;
+
+    // On peut faciliter la lecture des valeurs numériques
+	// en y insérant des `_`.
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+
+    // For et while sont très utiles, mais en D, on préfère foreach.
+    // Les deux points : '..', créent un intervalle continue de valeurs
+    // incluant la première mais excluant la dernière.
+    foreach(i; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(i);
+    }
+
+    // On peut également utiliser foreach_reverse pour itérer à l'envers.
+    foreach_reverse(i; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(i);
+        } else {
+            writeln("Non !");
+        }
+    }
+}
+```
+
+We can define new types with `struct`, `class`, `union`, and `enum`. Structs and unions
+are passed to functions by value (i.e. copied) and classes are passed by reference. Futhermore,
+we can use templates to parameterize all of these on both types and values!
+
+On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
+`union` et `enum`. Les structures et les unions sont passées au fonctions par
+valeurs (elle sont copiées) et les classes sont passées par référence. De plus,
+On peut utiliser les templates pour rendre toutes ces abstractions génériques.
+
+```d
+// Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
+struct LinkedList(T) {
+    T data = null;
+
+	// Utilisez '!' pour instancier un type paramétré.
+	// Encore une fois semblable à '<T>'
+    LinkedList!(T)* next;
+}
+
+class BinTree(T) {
+    T data = null;
+
+	// Si il n'y a qu'un seul paramètre de template,
+	// on peut s'abstenir de parenthèses.
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// Utilisez alias pour créer des abreviations pour les types.
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+// On peut tout aussi bien créer des templates de function !
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// On peut utiliser le mot-clé ref pour s'assurer que quelque chose est passé
+// par référence, et ceci, même si a et b sont d'ordinaire passés par valeur.
+// Ici ils seront toujours passés par référence à 'swap()'.
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// Avec les templates, on peut également passer des valeurs en paramètres.
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3); // T est 'int' par défaut
+
+```
+À propos de classes, parlons des propriétés. Une propriété est, en gros,
+une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
+la syntaxe des structures classiques (`struct.x = 7`) comme si il
+s'agissait de méthodes getter ou setter.
+
+```d
+// Considérons une classe paramétrée avec les types 'T' et 'U'
+class MyClass(T, U) {
+    T _data;
+    U _other;
+}
+
+// Et des méthodes "getter" et "setter" comme suit:
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+	// Les constructeurs s'apellent toujours 'this'.
+    this(T t, U u) {
+		// Ceci va appeller les setters ci-dessous.
+        data = t;
+        other = u;
+    }
+
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters
+    @property void data(T t) {
+        _data = t;
+    }
+
+    @property void other(U u) {
+        _other = u;
+    }
+}
+
+// Et on l'utilise de cette façon:
+void main() {
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+	// Importer le module 'stdio' de la bibliothèque standard permet
+	// d'écrire dans la console (les imports peuvent être locaux à une portée)
+    import std.stdio;
+
+	// On appelle les getters pour obtenir les valeurs.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+	// On appelle les setter pour assigner de nouvelles valeurs.
+    mc.data = 8;
+    mc.other = "eight";
+
+	// On appelle les setter pour obtenir les nouvelles valeurs.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
+}
+```
+
+With properties, we can add any amount of logic to
+our getter and setter methods, and keep the clean syntax of
+accessing members directly!
+
+Other object-oriented goodies at our disposal
+include `interface`s, `abstract class`es,
+and `override`ing methods. D does inheritance just like Java:
+Extend one class, implement as many interfaces as you please.
+
+We've seen D's OOP facilities, but let's switch gears. D offers
+functional programming with first-class functions, `pure`
+functions, and immutable data. In addition, all of your favorite
+functional algorithms (map, filter, reduce and friends) can be
+found in the wonderful `std.algorithm` module!
+
+Avec les propriétés, on peut constuire nos setters et nos getters
+comme on le souhaite, tout en gardant un syntaxe très propre,
+comme si on accédait directement à des membres de la classe.
+
+Les autres fonctionnalités orientées objets à notre disposition
+incluent les interfaces, les classes abstraites, et la surcharge
+de méthodes. D gère l'héritage comme Java: On ne peut hériter que
+d'une seule classe et implémenter autant d'interface que voulu.
+
+Nous venons d'explorer les fonctionnalités objet du D, mais changeons
+un peu de domaine. D permet la programmation fonctionelle, avec les fonctions
+de premier ordre, les fonctions `pure` et les données immuables.
+De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter)
+sont disponibles dans le module `std.algorithm`.
+
+```d
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // construit un intervalle excluant la dernière valeur.
+
+void main() {
+	// On veut un algorithm qui affiche la somme de la listes des carrés
+	// des entiers paires de 1 à 100. Un jeu d'enfant !
+
+	// On se content de passer des expressions lambda en paramètre à des templates.
+	// On peut fournier au template n'importe quelle fonction, mais dans notre
+	// cas, les lambdas sont pratiques.
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+Vous voyez comme on a calculé `num` comme on le ferait en haskell par exemple ?
+C'est grâce à une innvoation de D qu'on appelle "Uniform Function Call Syntax".
+Avec l'UFCS, on peut choisir d'écrire un appelle à une fonction de manière
+classique, ou comme un appelle à une méthode. Walter Brighter a écrit un
+article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
+Pour faire court, on peut appeller une fonction dont le premier paramètre
+est de type A, comme si c'était une méthode de A.
+
+J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça
+Voyons comment on le fait en D !
+
+```d
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+	// On veut calculer la racine carré de tous les nombres
+	// dans notre tableau, et profiter de tous les coeurs
+	// à notre disposition.
+    auto arr = new double[1_000_000];
+
+	// On utilise un index et une référence à chaque élément du tableau.
+	// On appelle juste la fonction parallel sur notre tableau !
+    foreach(i, ref elem; parallel(arr)) {
+        ref = sqrt(i + 1.0);
+    }
+}
+
+
+```
-- 
cgit v1.2.3


From 6313536895742385f743b05ed84c1efc274204f7 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:35:38 +0200
Subject: [d/fr] adds translation

---
 fr-fr/d.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index dfc3519d..5d72a2d0 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -1,10 +1,10 @@
 ---
 language: D
-filename: learnd.d
+filename: learnd-fr.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
 	- ["Quentin Ladeveze", "aceawan.eu"]
-lang: fr
+lang: fr-f
 ---
 
 ```d
-- 
cgit v1.2.3


From 7f8b8d036302ee7e7ba2c47b11c3833b864bffab Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:38:10 +0200
Subject: correct translator name

---
 fr-fr/d.html.markdown | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 5d72a2d0..f9dececb 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -3,6 +3,7 @@ language: D
 filename: learnd-fr.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+translators:
 	- ["Quentin Ladeveze", "aceawan.eu"]
 lang: fr-f
 ---
-- 
cgit v1.2.3


From 5507a389903c4b2ff66aa811f6952a78e99c3c7a Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:39:05 +0200
Subject: correct language

---
 fr-fr/d.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index f9dececb..2c90a628 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
 translators:
 	- ["Quentin Ladeveze", "aceawan.eu"]
-lang: fr-f
+lang: fr-fr
 ---
 
 ```d
-- 
cgit v1.2.3


From c759b6ea2bc1dd1ddad8d08bcdf5741d7e7711b0 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:39:44 +0200
Subject: removes english text

---
 fr-fr/d.html.markdown | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 2c90a628..d75f1083 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -25,11 +25,6 @@ de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.
 D est un langage de programmation moderne, généraliste, multi-paradigme qui contient
 des fonctionnalités aussi bien de bas-niveau que haut-niveau.
 
-D is actively developed by a large group of super-smart people and is spearheaded by
-[Walter Bright](https://en.wikipedia.org/wiki/Walter_Bright) and
-[Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
-With all that out of the way, let's look at some examples!
-
 D est activement développé par de nombreuses personnes très intelligents, guidées par
 [Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et
 [Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
-- 
cgit v1.2.3


From 00182d32f4e2eebf46d12910e885b0dde3eabdbc Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:40:27 +0200
Subject: removes english text

---
 fr-fr/d.html.markdown | 21 ---------------------
 1 file changed, 21 deletions(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index d75f1083..702de206 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -72,11 +72,6 @@ void main() {
     }
 }
 ```
-
-We can define new types with `struct`, `class`, `union`, and `enum`. Structs and unions
-are passed to functions by value (i.e. copied) and classes are passed by reference. Futhermore,
-we can use templates to parameterize all of these on both types and values!
-
 On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
 `union` et `enum`. Les structures et les unions sont passées au fonctions par
 valeurs (elle sont copiées) et les classes sont passées par référence. De plus,
@@ -204,22 +199,6 @@ void main() {
     writefln("Later: data = %d, str = %s", mc.data, mc.other);
 }
 ```
-
-With properties, we can add any amount of logic to
-our getter and setter methods, and keep the clean syntax of
-accessing members directly!
-
-Other object-oriented goodies at our disposal
-include `interface`s, `abstract class`es,
-and `override`ing methods. D does inheritance just like Java:
-Extend one class, implement as many interfaces as you please.
-
-We've seen D's OOP facilities, but let's switch gears. D offers
-functional programming with first-class functions, `pure`
-functions, and immutable data. In addition, all of your favorite
-functional algorithms (map, filter, reduce and friends) can be
-found in the wonderful `std.algorithm` module!
-
 Avec les propriétés, on peut constuire nos setters et nos getters
 comme on le souhaite, tout en gardant un syntaxe très propre,
 comme si on accédait directement à des membres de la classe.
-- 
cgit v1.2.3


From f8a2b28890d5d68a252d5bc0fd8247495b680e09 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 15:28:43 +0200
Subject: fix indentation and typos

---
 fr-fr/d.html.markdown | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 702de206..6782142d 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -4,7 +4,7 @@ filename: learnd-fr.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
 translators:
-	- ["Quentin Ladeveze", "aceawan.eu"]
+    - ["Quentin Ladeveze", "aceawan.eu"]
 lang: fr-fr
 ---
 
@@ -22,8 +22,8 @@ void main(string[] args) {
 
 Si vous êtes comme moi et que vous passez beaucoup trop de temps sur internet, il y a
 de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.org/).
-D est un langage de programmation moderne, généraliste, multi-paradigme qui contient
-des fonctionnalités aussi bien de bas-niveau que haut-niveau.
+D est un langage de programmation moderne, généraliste, multi-paradigmes qui contient
+des fonctionnalités aussi bien de bas niveau que de haut niveau.
 
 D est activement développé par de nombreuses personnes très intelligents, guidées par
 [Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et
@@ -34,18 +34,17 @@ Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
 import std.stdio;
 
 void main() {
-
-	//Les conditions et les boucles sont classiques.
+    //Les conditions et les boucles sont classiques.
     for(int i = 0; i < 10000; i++) {
         writeln(i);
     }
 
-	// On peut utiliser auto pour inférer automatiquement le
-	// type d'une variable.
+    // On peut utiliser auto pour inférer automatiquement le
+    // type d'une variable.
     auto n = 1;
 
     // On peut faciliter la lecture des valeurs numériques
-	// en y insérant des `_`.
+    // en y insérant des `_`.
     while(n < 10_000) {
         n += n;
     }
-- 
cgit v1.2.3


From 13c9d9af5cc60ae747d42f73d795f360a15f3fd8 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 15:33:48 +0200
Subject: fix indentation and typos

---
 fr-fr/d.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 6782142d..ee69ca34 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -90,7 +90,7 @@ class BinTree(T) {
     T data = null;
 
 	// Si il n'y a qu'un seul paramètre de template,
-	// on peut s'abstenir de parenthèses.
+	// on peut s'abstenir de mettre des parenthèses.
     BinTree!T left;
     BinTree!T right;
 }
-- 
cgit v1.2.3


From d7e3def01ec674a7578581c1fb8b003cd164d335 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 15:40:44 +0200
Subject: fix indentation and typos

---
 fr-fr/d.html.markdown | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index ee69ca34..96158683 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -72,9 +72,8 @@ void main() {
 }
 ```
 On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
-`union` et `enum`. Les structures et les unions sont passées au fonctions par
-valeurs (elle sont copiées) et les classes sont passées par référence. De plus,
-On peut utiliser les templates pour rendre toutes ces abstractions génériques.
+`union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés)
+De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
 
 ```d
 // Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
-- 
cgit v1.2.3


From 24ff15fe7a327232a0c33600ea70f8bc5c566eb3 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Wed, 21 Oct 2015 19:08:03 +0200
Subject: correct indentation

---
 fr-fr/d.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 96158683..9eacc2aa 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -88,8 +88,8 @@ struct LinkedList(T) {
 class BinTree(T) {
     T data = null;
 
-	// Si il n'y a qu'un seul paramètre de template,
-	// on peut s'abstenir de mettre des parenthèses.
+    // Si il n'y a qu'un seul paramètre de template,
+    // on peut s'abstenir de mettre des parenthèses.
     BinTree!T left;
     BinTree!T right;
 }
-- 
cgit v1.2.3


From a15486c2a843c7b1c76f0343da9436bf39d2e227 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Wed, 21 Oct 2015 19:08:52 +0200
Subject: correct indentation

---
 fr-fr/d.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 9eacc2aa..d9bd9b48 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -248,13 +248,13 @@ import std.parallelism : parallel;
 import std.math : sqrt;
 
 void main() {
-	// On veut calculer la racine carré de tous les nombres
-	// dans notre tableau, et profiter de tous les coeurs
-	// à notre disposition.
+    // On veut calculer la racine carré de tous les nombres
+    // dans notre tableau, et profiter de tous les coeurs
+    // à notre disposition.
     auto arr = new double[1_000_000];
 
-	// On utilise un index et une référence à chaque élément du tableau.
-	// On appelle juste la fonction parallel sur notre tableau !
+    // On utilise un index et une référence à chaque élément du tableau.
+    // On appelle juste la fonction parallel sur notre tableau !
     foreach(i, ref elem; parallel(arr)) {
         ref = sqrt(i + 1.0);
     }
-- 
cgit v1.2.3


From 4edbfa9e0394a4abb9301391cdebcc857559a5c7 Mon Sep 17 00:00:00 2001
From: Amru Eliwat <amru.eliwat@ensighten.com>
Date: Fri, 23 Oct 2015 23:17:35 -0700
Subject: Fixed 'modeling' and 'compatibility' typos

---
 fsharp.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fsharp.html.markdown b/fsharp.html.markdown
index 76318d7d..a2a87d57 100644
--- a/fsharp.html.markdown
+++ b/fsharp.html.markdown
@@ -335,10 +335,10 @@ module DataTypeExamples =
     let worker = Worker jdoe
 
     // ------------------------------------
-    // Modelling with types
+    // Modeling with types
     // ------------------------------------
 
-    // Union types are great for modelling state without using flags
+    // Union types are great for modeling state without using flags
     type EmailAddress =
         | ValidEmailAddress of string
         | InvalidEmailAddress of string
@@ -526,7 +526,7 @@ module AsyncExample =
     |> Async.RunSynchronously  // start them off
 
 // ================================================
-// .NET compatability
+// .NET compatibility
 // ================================================
 
 module NetCompatibilityExamples =
-- 
cgit v1.2.3


From d41fdbcba9a8d764ffcd1eaca453c7870567784f Mon Sep 17 00:00:00 2001
From: Kristian <kethomassen@gmail.com>
Date: Mon, 26 Oct 2015 17:56:28 +1000
Subject: Fixed typo in docs

+ Added a better description for 'nil'
---
 ruby.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ruby.html.markdown b/ruby.html.markdown
index 998b4bf7..a3fc859e 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -49,7 +49,7 @@ You shouldn't either
 10.* 5 #=> 50
 
 # Special values are objects
-nil # Nothing to see here
+nil # equivalent to null in other languages
 true # truth
 false # falsehood
 
@@ -122,7 +122,7 @@ puts "I'm printing!"
 
 # print to the output without a newline
 print "I'm printing!"
-#=> I'm printing! => nill
+#=> I'm printing! => nil
 
 # Variables
 x = 25 #=> 25
-- 
cgit v1.2.3


From 1bd371bcda266c594ab4a4be9868db32a157c296 Mon Sep 17 00:00:00 2001
From: Tom Anderson <twocs@users.noreply.github.com>
Date: Sat, 31 Oct 2015 22:43:43 +1030
Subject: Add section heading info

Give information about using comments for code sections
---
 matlab.html.markdown | 1 +
 1 file changed, 1 insertion(+)

diff --git a/matlab.html.markdown b/matlab.html.markdown
index 9d78978e..25f762bb 100644
--- a/matlab.html.markdown
+++ b/matlab.html.markdown
@@ -15,6 +15,7 @@ If you have any feedback please feel free to reach me at
 [osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
 
 ```matlab
+%% Code sections start with two percent signs. Section titles go on the same line.
 % Comments start with a percent sign.
 
 %{
-- 
cgit v1.2.3


From 38506983bb1d589734268b62bb87b4bad4601733 Mon Sep 17 00:00:00 2001
From: Willie Zhu <zhuwillie11@gmail.com>
Date: Sat, 31 Oct 2015 15:27:44 -0400
Subject: [edn/en] Fix grammar

---
 edn.html.markdown | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/edn.html.markdown b/edn.html.markdown
index 0a0dc9b5..d0bdddfc 100644
--- a/edn.html.markdown
+++ b/edn.html.markdown
@@ -5,13 +5,13 @@ contributors:
   - ["Jason Yeo", "https://github.com/jsyeo"]
 ---
 
-Extensible Data Notation or EDN for short is a format for serializing data.
+Extensible Data Notation (EDN) is a format for serializing data.
 
-The notation is used internally by Clojure to represent programs and it also
+The notation is used internally by Clojure to represent programs. It is also
 used as a data transfer format like JSON. Though it is more commonly used in
-Clojure land, there are implementations of EDN for many other languages.
+Clojure, there are implementations of EDN for many other languages.
 
-The main benefit of EDN over JSON and YAML is that it is extensible, which we
+The main benefit of EDN over JSON and YAML is that it is extensible. We
 will see how it is extended later on.
 
 ```Clojure
@@ -59,7 +59,7 @@ false
 ; Vectors allow random access
 [:gelato 1 2 -2]
 
-; Maps are associative data structures that associates the key with its value
+; Maps are associative data structures that associate the key with its value
 {:eggs        2
  :lemon-juice 3.5
  :butter      1}
@@ -68,7 +68,7 @@ false
 {[1 2 3 4] "tell the people what she wore",
  [5 6 7 8] "the more you see the more you hate"}
 
-; You may use commas for readability. They are treated as whitespaces.
+; You may use commas for readability. They are treated as whitespace.
 
 ; Sets are collections that contain unique elements.
 #{:a :b 88 "huat"}
@@ -82,11 +82,11 @@ false
 #MyYelpClone/MenuItem {:name "eggs-benedict" :rating 10}
 
 ; Let me explain this with a clojure example. Suppose I want to transform that
-; piece of edn into a MenuItem record.
+; piece of EDN into a MenuItem record.
 
 (defrecord MenuItem [name rating])
 
-; To transform edn to clojure values, I will need to use the built in EDN
+; To transform EDN to clojure values, I will need to use the built in EDN
 ; reader, edn/read-string
 
 (edn/read-string "{:eggs 2 :butter 1 :flour 5}")
-- 
cgit v1.2.3


From 6e9e1f4af018dc0e277c968d9b5fe011e0a1ce97 Mon Sep 17 00:00:00 2001
From: Ryan <myoldemailname@gmail.com>
Date: Sat, 31 Oct 2015 16:49:57 -0700
Subject: Added new resource to javascript

---
 javascript.html.markdown | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/javascript.html.markdown b/javascript.html.markdown
index e285ca4e..98261334 100644
--- a/javascript.html.markdown
+++ b/javascript.html.markdown
@@ -561,7 +561,9 @@ of the language.
 
 [Eloquent Javascript][8] by Marijn Haverbeke is an excellent JS book/ebook with attached terminal
 
-[Javascript: The Right Way][9] is a guide intended to introduce new developers to JavaScript and help experienced developers learn more about its best practices.
+[Eloquent Javascript - The Annotated Version][9] by Gordon Zhu is also a great derivative of Eloquent Javascript with extra explanations and clarifications for some of the more complicated examples.
+
+[Javascript: The Right Way][10] is a guide intended to introduce new developers to JavaScript and help experienced developers learn more about its best practices.
 
 
 In addition to direct contributors to this article, some content is adapted from
@@ -577,4 +579,5 @@ Mozilla Developer Network.
 [6]: http://www.amazon.com/gp/product/0596805527/
 [7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
 [8]: http://eloquentjavascript.net/
-[9]: http://jstherightway.org/
+[9]: http://watchandcode.com/courses/eloquent-javascript-the-annotated-version
+[10]: http://jstherightway.org/
-- 
cgit v1.2.3


From 0e1a77c065076993a170bc2874987a6289856a9f Mon Sep 17 00:00:00 2001
From: Willie Zhu <zhuwillie11@gmail.com>
Date: Sat, 31 Oct 2015 22:31:27 -0400
Subject: [whip/en] Fix typos

---
 whip.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/whip.html.markdown b/whip.html.markdown
index 61c301a5..e7e5e427 100644
--- a/whip.html.markdown
+++ b/whip.html.markdown
@@ -9,7 +9,7 @@ filename: whip.lisp
 ---
 
 Whip is a LISP-dialect made for scripting and simplified concepts.
-It has also borrowed a lot of functions and syntax from Haskell(a non-related language).
+It has also borrowed a lot of functions and syntax from Haskell (a non-related language).
 
 These docs were written by the creator of the language himself. So is this line.
 
@@ -172,12 +172,12 @@ undefined ; user to indicate a value that hasn't been set
 ; Comprehensions
 
 ; `range` or `..` generates a list of numbers for
-; each number between it's two args.
+; each number between its two args.
 (range 1 5) ; => (1 2 3 4 5)
 (.. 0 2)    ; => (0 1 2)
 
-; `map` applies it's first arg(which should be a lambda/function)
-; to each item in the following arg(which should be a list)
+; `map` applies its first arg (which should be a lambda/function)
+; to each item in the following arg (which should be a list)
 (map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4)
 
 ; Reduce
-- 
cgit v1.2.3


From 06c6c0fe2c03f6479c5906a807a88842b780cce9 Mon Sep 17 00:00:00 2001
From: poetienshul <ethantien@hotmail.com>
Date: Sat, 31 Oct 2015 23:20:00 -0400
Subject: visualbasic Commenting spacing inconsistency

---
 visualbasic.html.markdown | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/visualbasic.html.markdown b/visualbasic.html.markdown
index accdbf56..dfb89307 100644
--- a/visualbasic.html.markdown
+++ b/visualbasic.html.markdown
@@ -9,13 +9,13 @@ filename: learnvisualbasic.vb
 Module Module1
 
     Sub Main()
-        ' A Quick Overview of Visual Basic Console Applications before we dive
-        ' in to the deep end.
-        ' Apostrophe starts comments.
-        ' To Navigate this tutorial within the Visual Basic Complier, I've put
-        ' together a navigation system.
-        ' This navigation system is explained however as we go deeper into this
-        ' tutorial, you'll understand what it all means.
+        'A Quick Overview of Visual Basic Console Applications before we dive
+        'in to the deep end.
+        'Apostrophe starts comments.
+        'To Navigate this tutorial within the Visual Basic Complier, I've put
+        'together a navigation system.
+        'This navigation system is explained however as we go deeper into this
+        'tutorial, you'll understand what it all means.
         Console.Title = ("Learn X in Y Minutes")
         Console.WriteLine("NAVIGATION") 'Display
         Console.WriteLine("")
@@ -32,9 +32,9 @@ Module Module1
         Console.WriteLine("50. About")
         Console.WriteLine("Please Choose A Number From The Above List")
         Dim selection As String = Console.ReadLine
-        ' The "Case" in the Select statement is optional.
-        ' For example, "Select selection" instead of "Select Case selection"
-        ' will also work.
+        'The "Case" in the Select statement is optional.
+        'For example, "Select selection" instead of "Select Case selection"
+        'will also work.
         Select Case selection
             Case "1" 'HelloWorld Output
                 Console.Clear() 'Clears the application and opens the private sub
@@ -91,12 +91,12 @@ Module Module1
     'Two
     Private Sub HelloWorldInput()
         Console.Title = "Hello World YourName | Learn X in Y Minutes"
-        ' Variables
-        ' Data entered by a user needs to be stored.
-        ' Variables also start with a Dim and end with an As VariableType.
+        'Variables
+        'Data entered by a user needs to be stored.
+        'Variables also start with a Dim and end with an As VariableType.
 
-        ' In this tutorial, we want to know what your name, and make the program
-        ' respond to what is said.
+        'In this tutorial, we want to know what your name, and make the program
+        'respond to what is said.
         Dim username As String
         'We use string as string is a text based variable.
         Console.WriteLine("Hello, What is your name? ") 'Ask the user their name.
-- 
cgit v1.2.3


From 244c649f46cad2d3955c97db26772720307647d1 Mon Sep 17 00:00:00 2001
From: ingmrb <ingmrb@users.noreply.github.com>
Date: Sun, 1 Nov 2015 01:40:07 -0300
Subject: [gites] fixed typos

---
 es-es/git-es.html.markdown | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 18b544b4..4e1e68ba 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -18,11 +18,11 @@ versionar y administrar nuestro código fuente.
 
 ## Versionamiento, conceptos.
 
-### Qué es el control de versiones?
+### ¿Qué es el control de versiones?
 El control de versiones es un sistema que guarda todos los cambios realizados en
 uno o varios archivos, a lo largo del tiempo.
 
-### Versionamiento centralizado vs Versionamiento Distribuido.
+### Versionamiento centralizado vs versionamiento distribuido.
 
 + El versionamiento centralizado se enfoca en sincronizar, rastrear, y respaldar
   archivos.
@@ -33,9 +33,9 @@ uno o varios archivos, a lo largo del tiempo.
 
 [Información adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
 
-### Por qué usar Git?
+### ¿Por qué usar Git?
 
-* Se puede trabajar sin conexion.
+* Se puede trabajar sin conexión.
 * ¡Colaborar con otros es sencillo!.
 * Derivar, crear ramas del proyecto (aka: Branching) es fácil.
 * Combinar (aka: Merging)
@@ -47,7 +47,7 @@ uno o varios archivos, a lo largo del tiempo.
 ### Repositorio
 
 Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka:
-comits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
+commits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
 y que sus atributos otorgan acceso al historial del elemento, además de otras
 cosas.
 
@@ -62,12 +62,12 @@ y mas.
 
 ### Directorio de trabajo (componentes del repositorio)
 
-Es basicamente los directorios y archivos dentro del repositorio. La mayoría de
+Es básicamente los directorios y archivos dentro del repositorio. La mayoría de
 las veces se le llama "directorio de trabajo".
 
 ### Índice (componentes del directorio .git)
 
-El índice es el área de inicio en git. Es basicamente la capa que separa el
+El índice es el área de inicio en git. Es básicamente la capa que separa el
 directorio de trabajo del repositorio en git. Esto otorga a los desarrolladores
 más poder sobre lo que se envía y se recibe del repositorio.
 
-- 
cgit v1.2.3

-- 
cgit v1.2.3


From db482790ec142138118a8d71a1a7b17a99cd1491 Mon Sep 17 00:00:00 2001
From: ingmrb <ingmrb@users.noreply.github.com>
Date: Sun, 1 Nov 2015 02:14:51 -0300
Subject: [json/es] fixed typos

---
 es-es/json-es.html.markdown | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/es-es/json-es.html.markdown b/es-es/json-es.html.markdown
index fff678eb..c98049f9 100644
--- a/es-es/json-es.html.markdown
+++ b/es-es/json-es.html.markdown
@@ -21,22 +21,22 @@ JSON en su forma más pura no tiene comentarios, pero la mayoría de los parsead
   "llaves": "siempre debe estar entre comillas (ya sean dobles o simples)",
   "numeros": 0,
   "strings": "Høla, múndo. Todo el unicode está permitido, así como \"escapar\".",
-  "soporta booleanos?": true,
-  "vacios": null,
+  "¿soporta booleanos?": true,
+  "vacíos": null,
 
   "numero grande": 1.2e+100,
 
   "objetos": {
-    "comentario": "La mayoria de tu estructura vendra de objetos.",
+    "comentario": "La mayoría de tu estructura vendrá de objetos.",
 
     "arreglo": [0, 1, 2, 3, "Los arreglos pueden contener cualquier cosa.", 5],
 
     "otro objeto": {
-      "comentario": "Estas cosas pueden estar anidadas, muy util."
+      "comentario": "Estas cosas pueden estar anidadas, muy útil."
     }
   },
 
-  "tonteria": [
+  "tontería": [
     {
       "fuentes de potasio": ["bananas"]
     },
@@ -50,10 +50,10 @@ JSON en su forma más pura no tiene comentarios, pero la mayoría de los parsead
   
   "estilo alternativo": {
     "comentario": "Mira esto!"
-  , "posicion de la coma": "no importa - mientras este antes del valor, entonces sera valido"
-  , "otro comentario": "que lindo"
+  , "posición de la coma": "no importa - mientras este antes del valor, entonces sera válido"
+  , "otro comentario": "qué lindo"
   },
 
-  "eso fue rapido": "Y, estas listo. Ahora sabes todo lo que JSON tiene para ofrecer."
+  "eso fue rapido": "Y, estás listo. Ahora sabes todo lo que JSON tiene para ofrecer."
 }
 ```
-- 
cgit v1.2.3


From 471c4b129bceb74c5c38758cebd9851d9f838064 Mon Sep 17 00:00:00 2001
From: ingmrb <ingmrb@users.noreply.github.com>
Date: Sun, 1 Nov 2015 02:16:35 -0300
Subject: [javascript/es] fixed typos

---
 es-es/javascript-es.html.markdown | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index d475cf42..c5419a21 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -30,7 +30,7 @@ Aunque JavaScript no sólo se limita a los navegadores web: Node.js, Un proyecto
 // Cada sentencia puede ser terminada con punto y coma ;
 hazAlgo();
 
-// ... aunque no es necesario, ya que el punto y coma se agrega automaticamente
+// ... aunque no es necesario, ya que el punto y coma se agrega automáticamente
 // cada que se detecta una nueva línea, a excepción de algunos casos.
 hazAlgo()
 
@@ -109,7 +109,7 @@ null == undefined; // = true
 null === undefined; // false
 
 // Los Strings funcionan como arreglos de caracteres
-// Puedes accesar a cada caracter con la función charAt()
+// Puedes acceder a cada caracter con la función charAt()
 "Este es un String".charAt(0);  // = 'E'
 
 // ...o puedes usar la función substring() para acceder a pedazos más grandes
@@ -301,7 +301,7 @@ i; // = 5 - en un lenguaje que da ámbitos por bloque esto sería undefined, per
 //inmediatamente", que preveé variables temporales de fugarse al ámbito global
 (function(){
     var temporal = 5;
-    // Podemos accesar al ámbito global asignando al 'objeto global', el cual
+    // Podemos acceder al ámbito global asignando al 'objeto global', el cual
     // en un navegador siempre es 'window'. El objeto global puede tener
     // un nombre diferente en ambientes distintos, por ejemplo Node.js .
     window.permanente = 10;
@@ -321,7 +321,7 @@ function decirHolaCadaCincoSegundos(nombre){
         alert(texto);
     }
     setTimeout(interna, 5000);
-    // setTimeout es asíncrono, así que la funcion decirHolaCadaCincoSegundos 
+    // setTimeout es asíncrono, así que la función decirHolaCadaCincoSegundos 
     // terminará inmediatamente, y setTimeout llamará a interna() a los cinco segundos
     // Como interna está "cerrada dentro de" decirHolaCadaCindoSegundos, interna todavía tiene
     // acceso a la variable 'texto' cuando es llamada.
@@ -339,7 +339,7 @@ var miObjeto = {
 };
 miObjeto.miFuncion(); // = "¡Hola Mundo!"
 
-// Cuando las funciones de un objeto son llamadas, pueden accesar a las variables 
+// Cuando las funciones de un objeto son llamadas, pueden acceder a las variables 
 // del objeto con la palabra clave 'this'.
 miObjeto = {
     miString: "¡Hola Mundo!",
@@ -401,11 +401,11 @@ var MiConstructor = function(){
 miNuevoObjeto = new MiConstructor(); // = {miNumero: 5}
 miNuevoObjeto.miNumero; // = 5
 
-// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a accesar a una
+// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a acceder a una
 // propiedad en un objeto que no existe en el objeto el intérprete buscará en
 // el prototipo.
 
-// Algunas implementaciones de JavaScript te permiten accesar al prototipo de 
+// Algunas implementaciones de JavaScript te permiten acceder al prototipo de 
 // un objeto con la propiedad __proto__. Mientras que esto es útil para explicar
 // prototipos, no es parte del estándar; veremos formas estándar de usar prototipos
 // más adelante.
@@ -440,7 +440,7 @@ miPrototipo.sentidoDeLaVida = 43;
 miObjeto.sentidoDeLaVida; // = 43
 
 // Mencionabamos anteriormente que __proto__ no está estandarizado, y que no 
-// existe una forma estándar de accesar al prototipo de un objeto. De todas formas.
+// existe una forma estándar de acceder al prototipo de un objeto. De todas formas.
 // hay dos formas de crear un nuevo objeto con un prototipo dado.
 
 // El primer método es Object.create, el cual es una adición reciente a JavaScript,
-- 
cgit v1.2.3


From 5b58fae6a3770341207e810a466c0be863d80782 Mon Sep 17 00:00:00 2001
From: ingmrb <ingmrb@users.noreply.github.com>
Date: Sun, 1 Nov 2015 02:19:50 -0300
Subject: [javascript /es] fixed typos.

---
 es-es/javascript-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index c5419a21..3273f7ad 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -186,7 +186,7 @@ miObjeto.miLlave; // = "miValor"
 // agregar nuevas llaves.
 miObjeto.miTerceraLlave = true;
 
-// Si intentas accesar con una llave que aún no está asignada tendrás undefined.
+// Si intentas acceder con una llave que aún no está asignada tendrás undefined.
 miObjeto.miCuartaLlave; // = undefined
 
 ///////////////////////////////////
-- 
cgit v1.2.3


From a3b69a2275c343d4e5b4e58d6eb4010517e0eef9 Mon Sep 17 00:00:00 2001
From: ingmrb <ingmrb@users.noreply.github.com>
Date: Sun, 1 Nov 2015 02:24:00 -0300
Subject: [javascript /es] typo

---
 es-es/javascript-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index 3273f7ad..9ef0c63e 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -476,7 +476,7 @@ typeof miNumero; // = 'number'
 typeof miNumeroObjeto; // = 'object'
 miNumero === miNumeroObjeyo; // = false
 if (0){
-    // Este código no se ejecutara porque 0 es false.
+    // Este código no se ejecutará porque 0 es false.
 }
 
 // Aún así, los objetos que envuelven y los prototipos por defecto comparten
-- 
cgit v1.2.3